DIRECTORY
BasicTime,
BcdDefs USING [VersionStamp],
IO,
RESOut USING [
Handle, PChar, PCr, PNext, PNextNull, PNextUnsigned, PNull, PRope, PUnsigned],
Rope,
STDebugDefs USING [
HashForSei, PutHashString, PutModeName, PutTypeName, ShowLinks,
STCopyRead, TableBase, TableSize],
Symbols USING [
BodyRecord, bodyType, BTIndex, BTNull, CSENull, CTXIndex, CTXNull, CTXRecord, 
ctxType, ExtensionType, HTIndex, HTNull, HTRecord, htType, ISEIndex, 
ISENull, MDIndex, MDRecord, mdType, SEIndex, SENull, SERecord, seType],
SymbolSegment USING [ExtIndex, ExtRecord, extType],
Table USING [Base],
Tree USING [Link, Null, NullIndex];

STDebugSymbols: PROGRAM 
IMPORTS BasicTime, IO, RESOut, STDebugDefs 
EXPORTS STDebugDefs =
BEGIN OPEN Symbols, RESOut, STDebugDefs;
Handle: TYPE = RESOut.Handle;
ROPE: TYPE = Rope.ROPE;
ISERecord: TYPE = Symbols.SERecord.id;

PU: PROCEDURE [h: Handle, u: UNSPECIFIED] = LOOPHOLE[RESOut.PUnsigned];
PNextU: PROCEDURE [h: Handle, s: ROPE, num: UNSPECIFIED, indent: CARDINAL _ 2] =
LOOPHOLE[RESOut.PNextUnsigned];

NextSe: PUBLIC PROCEDURE [h: Handle, sei: ISEIndex] RETURNS [ISEIndex] =
BEGIN
seb: Table.Base;
ser: ISERecord;
IF sei = ISENull THEN RETURN [ISENull];
seb _ TableBase[h, seType];
STCopyRead[h: h,  to: @ser, from: @seb[sei], nwords: SIZE [ISERecord]];
WITH ser SELECT FROM
terminal => RETURN[ISENull];
linked => RETURN[link];
ENDCASE -- sequential-- => RETURN[LOOPHOLE[sei+SIZE[sequential id SERecord]]];
END;

FindExt: PRIVATE PROCEDURE [h: Handle, sei: ISEIndex] RETURNS
[type: ExtensionType, tree: Tree.Link] =
BEGIN OPEN SymbolSegment;
extb: Table.Base = TableBase[h, extType];
exti: ExtIndex;
extr: ExtRecord;
extLimit: ExtIndex = LOOPHOLE[TableSize[h, extType]];

FOR exti _ FIRST[ExtIndex], exti + SIZE[ExtRecord] UNTIL exti = extLimit DO
STCopyRead[h: h,  to: @extr, from: @extb[exti], nwords: SIZE[ExtRecord]];
IF extr.sei = sei THEN RETURN[extr.type, extr.tree];
ENDLOOP;
RETURN[none, Tree.Null];
END;

PutAsSei: PUBLIC PROCEDURE [h: Handle, sei: Symbols.SEIndex] RETURNS [id: BOOL _ FALSE] =
BEGIN
seb: Table.Base;
ser: SERecord;
hti: HTIndex;

seb _ TableBase[h, seType];
STCopyRead[h: h,  to: @ser, from: @seb[sei],
nwords: SIZE [SERecord]];
PCr[h];
PRope[h, "seb["]; PU[h, sei]; PRope[h, "] "];
WITH se: ser SELECT FROM
id =>
BEGIN
id _ TRUE;
hti _ HashForSei[h, LOOPHOLE[sei]];
PutHashString[h, hti];
PNextNull[h, "hti", hti, HTNull];
PNextNull[h, "ctx", se.idCtx, CTXNull];
PNextU[h, "value", se.idValue];
PNextU[h, "info", se.idInfo];
PNextU[h, "type", se.idType];
IF se.extended THEN 
BEGIN
es: IO.STREAM _ IO.ROS[];
type: ExtensionType;
tree: Tree.Link;
[type, tree] _ FindExt[h, LOOPHOLE[sei]];
es.PutF["extended[%g,%d]", 
[rope[SELECT type FROM
value => "val",
form => "for",
default => "def",
ENDCASE => "non"]],
[cardinal[LOOPHOLE[tree]]]];
PNext[h, es.RopeFromROS[]];
END;
IF se.public THEN PNext[h, "public"];
IF se.immutable THEN PNext[h, "immutable"];
IF se.constant THEN PNext[h, "constant"];
IF se.linkSpace THEN PNext[h, "linkSpace"];
WITH se SELECT FROM
terminal => PNext[h, "terminal"];
linked => PNextNull[h, "linked", link, ISENull];
sequential => NULL;
ENDCASE;
END;
cons => 
BEGIN
WITH se SELECT FROM
transfer => PutModeName[h, mode];
ENDCASE => PutTypeName[h, se.typeTag];
WITH cse: se SELECT FROM
mode => NULL;
basic =>
BEGIN
PRope[h, " - code: "]; PUnsigned[h, cse.code];
PNextU[h, "length", cse.length];
IF cse.ordered THEN PNext[h, "ordered"];
END;
enumerated =>
BEGIN
PRope[h, " - valCtx: "];
PU[h, cse.valueCtx]; PNextU[h, "nVals", cse.nValues];
IF cse.ordered THEN PNext[h, "ordered"];
IF cse.machineDep THEN PNext[h, "machineDep"];
IF cse.sparse THEN PNext[h, "sparse"];
IF cse.unpainted THEN PNext[h, "unpainted"];
END;
record =>
BEGIN
PRope[h, " - fieldCtx: "]; PU[h, cse.fieldCtx];
PNextU[h, "length", cse.length];
WITH lnkp: cse SELECT FROM
linked => PNextU[h, "linkType",lnkp.linkType];
ENDCASE;
IF cse.argument THEN PNext[h, "argument"];
IF cse.monitored THEN PNext[h, "monitored"];
IF cse.painted THEN PNext[h, "painted"];
IF cse.machineDep THEN PNext[h, "machineDep"];
IF cse.hints.variant THEN PNext[h, "variant"];
IF cse.hints.comparable THEN PNext[h, "comparable"];
IF cse.hints.assignable THEN PNext[h, "assignable"];
IF cse.hints.privateFields THEN PNext[h, "privateFields"];
IF cse.hints.unifield THEN PNext[h, "unifield"];
IF cse.hints.refField THEN PNext[h, "refField"];
IF cse.hints.default THEN PNext[h, "default"];
IF cse.hints.voidable THEN PNext[h, "voidable"];
END;
ref =>
BEGIN
PRope[h, " - refT: "]; PU[h, cse.refType];
IF cse.counted THEN PNext[h, "counted"];
IF cse.list THEN PNext[h, "list"];
IF cse.var THEN PNext[h, "var"];
IF cse.ordered THEN PNext[h, "ordered"];
IF cse.readOnly THEN PNext[h, "readOnly"];
IF cse.basing THEN PNext[h, "basing"];
END;
array =>
BEGIN
PRope[h, " - index: "]; PU[h, cse.indexType];
PNextU[h, "comp", cse.componentType];
IF cse.packed THEN PNext[h, "packed"];
END;
arraydesc =>
BEGIN
PRope[h, " - of: "]; PU[h, cse.describedType];
IF cse.readOnly THEN PNext[h, "readOnly"];
IF cse.var THEN PNext[h, "var"];
END;
transfer =>
BEGIN
IF cse.safe THEN PNext[h, "safe"];
PNextNull[h, "in", cse.typeIn, CSENull];
PNextNull[h, "out", cse.typeOut, CSENull];
END;
definition =>
BEGIN
PRope[h, " - defCtx: "]; PU[h, cse.defCtx];
IF cse.named THEN PNext[h, "named"];
END;
union =>
BEGIN
PRope[h, " - tag: "]; PNull[h, cse.tagSei, SENull];
PNextU[h, "caseCtx", cse.caseCtx];
IF cse.overlaid THEN PNext[h, "overlaid"];
IF cse.controlled THEN PNext[h, "controlled"];
IF cse.machineDep THEN PNext[h, "machineDep"];
IF cse.hints.equalLengths THEN PNext[h, "equalLengths"];
IF cse.hints.refField THEN PNext[h, "refField"];
IF cse.hints.default THEN PNext[h, "default"];
IF cse.hints.voidable THEN PNext[h, "voidable"];
END;
sequence =>
BEGIN
PRope[h, " - tag: "]; PNull[h, cse.tagSei, SENull];
PNextU[h, "comp", cse.componentType];
IF cse.controlled THEN PNext[h, "controlled"];
IF cse.packed THEN PNext[h, "packed"];
IF cse.machineDep THEN PNext[h, "machineDep"];
END;
relative =>
BEGIN
PRope[h, " - base: "]; PU[h, cse.baseType];
PNextU[h, "offset", cse.offsetType];
PNextU[h, "result", cse.resultType];
END;
subrange =>
BEGIN
PRope[h, " - of: "]; PNull[h, cse.rangeType, SENull];
PNextU[h, "origin", cse.origin];
PNextU[h, "range", cse.range];
IF cse.filled THEN PNext[h, "filled"];
IF cse.empty THEN PNext[h, "empty"];
END;
long, real =>
BEGIN
PRope[h, " - of: "]; PNull[h, cse.rangeType, SENull];
END;
opaque =>
BEGIN
PRope[h, " - id(se): "]; PNull[h, cse.id, SENull];
PNextU[h, "length", cse.length];
IF cse.lengthKnown THEN PNext[h, "lengthKnown"];
END;
zone =>
BEGIN
IF cse.counted THEN PNext[h, "counted"];
IF cse.mds THEN PNext[h, "mds"];
END;
ENDCASE;
END;
ENDCASE;
IF ShowLinks[h] THEN
BEGIN
IF ser.mark3 THEN PNext[h, "mk3"];
IF ser.mark4 THEN PNext[h, "mk4"];
END;
END;

PutAsHti: PUBLIC PROCEDURE [h: Handle, hti: Symbols.HTIndex] =
BEGIN
ht: LONG DESCRIPTOR FOR ARRAY HTIndex OF HTRecord;
htr: HTRecord;

ht _ DESCRIPTOR[TableBase[h, htType], 0]; -- ignore length
STCopyRead[h: h,  to: @htr, from: @ht[hti], nwords: SIZE[HTRecord]];
PCr[h];
PRope[h, "ht["]; PU[h, hti]; PRope[h, "] "];
PutHashString[h, hti];
PNextU[h, "ssI", htr.ssIndex];
PNextU[h, "link", htr.link];
IF htr.anyInternal THEN PNext[h, "anyInt"];
IF htr.anyPublic THEN PNext[h, "anyPub"];
END;

PutAsCti: PUBLIC PROCEDURE [h: Handle, cti: Symbols.CTXIndex] =
BEGIN
ctxb: Table.Base;
ctx: CTXRecord;

ctxb _ TableBase[h, ctxType];
STCopyRead[h: h,  to: @ctx, from: @ctxb[cti],
nwords: SIZE[CTXRecord]];
PCr[h];
PRope[h, "ctx["]; PU[h, cti]; PRope[h, "] level: "];
PU[h, 8*ctx.levelOrigin + ctx.levelOffset]; 
PNextU[h, "seList", ctx.seList];
IF ctx.varUpdated THEN PNext[h, "varUpdated"];
IF ctx.ctxType # nil THEN
BEGIN
WITH ctx SELECT FROM
simple => 
BEGIN
PNextU[h, "simple - copied", copied.ORD];
END;
imported => 
BEGIN
PNextU[h, "imported - link", includeLink];
END;
included => 
BEGIN
PCr[h]; PRope[h, "    "];
PRope[h, "included - chain: "]; PNull[h, chain, CTXNull];
PNextU[h, "module", module];
PNextU[h, "map", map];
IF closed THEN PNext[h, "closed",,6];
IF complete THEN PNext[h, "complete",,6];
IF restricted THEN PNext[h, "restricted",,6];
IF reset THEN PNext[h, "reset",,6];
END;
ENDCASE;
END;
END;

PutAsBti: PUBLIC PROCEDURE [h: Handle, bti: Symbols.BTIndex] =
BEGIN
bb: Table.Base;
btr: BodyRecord;

bb _ TableBase[h, bodyType];
STCopyRead[h: h,  to: @btr, from: @bb[bti],
nwords: SIZE[BodyRecord]];
PCr[h];
PRope[h, "bb["]; PU[h, bti]; PRope[h, "] link: "];
IF btr.link.index = BTNull THEN PRope[h, "Null"]
ELSE
BEGIN
PU[h, btr.link.index];
PRope[h, (IF btr.link.which = sibling THEN " (sib)" ELSE " (parent)")];
END;
PNextNull[h, "firstSon", btr.firstSon, BTNull];
PNextNull[h, "localCtx", btr.localCtx, CTXNull];
PNextU[h, "level", btr.level];
PNextU[h, "source", btr.sourceIndex];
PCr[h]; PRope[h, "    "];
WITH btr.info SELECT FROM
Internal =>
BEGIN
PRope[h, "Internal - tree: "]; PNull[h, bodyTree, Tree.NullIndex];
PNextU[h, "thread", thread, 6];
PNextU[h, "frameSz", frameSize, 6];
END;
External =>
BEGIN
PRope[h, "External - bytes: "]; PU[h, bytes];
PNextU[h, "startInd", startIndex, 6];
PNextU[h, "indLen", indexLength, 6];
END;
ENDCASE;
WITH bc: btr SELECT FROM
Callable =>
BEGIN
PCr[h]; PRope[h, "    Callable - id(se): "]; PU[h, bc.id];
IF bc.id # ISENull THEN {
hti: HTIndex = HashForSei[h, bc.id];
PRope[h, " ("]; PutHashString[h, hti]; PChar[h, ')]};
PNextU[h, "ioType", bc.ioType, 6];
PNextU[h, "entIndex", bc.entryIndex, 6];
WITH bc SELECT FROM
Inner => PNextU[h, "frameOff", frameOffset, 6];
Catch => PNextU[h, "Catch, index", index, 6];
ENDCASE;
IF bc.inline THEN PNext[h, "inline",,6];
IF bc.monitored THEN PNext[h, "monitored",,6];
IF bc.noXfers THEN PNext[h, "noXfers",,6];
IF bc.resident THEN PNext[h, "resident",,6];
IF bc.entry THEN PNext[h, "entry",,6];
IF bc.internal THEN PNext[h, "internal",,6];
IF bc.hints.safe THEN PNext[h, "safe",,6];
IF bc.hints.argUpdated THEN PNext[h, "argUpdated",,6];
IF bc.hints.nameSafe THEN PNext[h, "nameSafe",,6];
END;
Other =>
BEGIN
PCr[h]; PRope[h, "    Other - relOffset: "]; PU[h, bc.relOffset];
END;
ENDCASE;
END;

PutAsMdi: PUBLIC PROCEDURE [h: Handle, mdi: Symbols.MDIndex] =
BEGIN
mdb: Table.Base;
mdr: MDRecord;

mdb _ TableBase[h, mdType];
STCopyRead[h: h,  to: @mdr, from: @mdb[mdi],
nwords: SIZE[MDRecord]];
PCr[h];
PRope[h, "mdb["]; PU[h, mdi]; PRope[h, "] stamp: "]; PutVersion[h, mdr.stamp];
PNextU[h, "modId", mdr.moduleId];
PNextU[h, "fileId", mdr.fileId];
PNextNull[h, "ctx", mdr.ctx, CTXNull];
PNextNull[h, "defaultImport", mdr.defaultImport, CTXNull];
PNextUnsigned[h, "file", mdr.file];
IF mdr.shared THEN PNext[h, "shared"];
IF mdr.exported THEN PNext[h, "exported"];
END;

PutVersion: PUBLIC PROCEDURE [h: Handle, stamp: BcdDefs.VersionStamp] =
BEGIN
s: IO.STREAM _ IO.ROS[];
s.PutF["%g on %b#%b#", 
[time[BasicTime.FromNSTime[stamp.time]]], [cardinal[stamp.net]], [cardinal[stamp.host]]];
PRope[h, IO.RopeFromROS[s]];
RETURN
END;

END.

®STDebugSymbols.mesa  
Edited by Bruce,  18-Sep-81 20:38:56
Edited by Sweet,   8-Jul-83 23:58:33
Edited by Haynes,  29-Nov-82 20:24:50
Sweet May 16, 1986 3:55:35 pm PDT
�Ê
W˜Jš
œ™Jš
œ$™$Jš
œ$™$š
œ%™%Icode™!—J˜š
Ïk	˜	J˜
Jšœ�œ˜Jš�œ
˜šœ�œ˜Jš
œN˜N—Jš
œ˜šœ�œ˜J˜?J˜"—šœ�œ˜J˜NJ˜EJ˜G—Jšœ�œ ˜3Jšœ�œ˜Jšœ�œ˜#—J˜šœ�œ
˜Jš�œ�œ˜+Jš�œ˜Jš�œ
�œ˜(Jšœ�œ˜Jš�œ�œ�œ
˜Jšœ�œ˜&—˜Jš�œ�	œ�œ�œ˜Gš
Ïnœ�	œ�œ�œ
�œ˜PJš�œ˜J˜—šžœ�œ
�	œ�œ
˜HJš
�˜J˜J˜Jš�œ�œ
�œ˜'J˜Jšœ5�œ˜Gš�œ�œ
�˜Jšœ�œ
˜Jšœ
�œ˜Jš�œ�œ
�œ�œ˜N—Jš�œ
˜J˜—šžœ�œ
�	œ�˜=J˜(Jš�œ
�œ˜J˜)J˜J˜Jšœ�œ˜5J˜š	�œ�œ�œ�œ�˜KJšœ8�œ
˜IJš�œ�œ
�œ˜4Jš�œ
˜—Jš�œ˜Jš�œ
˜J˜—šžœ�œ
�	œ#�œ�œ�œ˜YJš
�˜J˜J˜J˜
J˜J˜˜,Jšœ�œ
˜—J˜Jšœ�œ˜-š�œ	�œ
�˜˜Jš
�˜Jšœ�œ
˜
Jšœ�œ˜#J˜J˜!J˜'J˜J˜J˜š�œ
�œ
˜Jš
�˜Jš	œ�œ
�œ�œ
�œ˜J˜J˜Jšœ�œ˜)š
œ˜šœ�œ�˜J˜J˜J˜Jš�œ˜—Jšœ
�œ
˜—J˜Jš�œ
˜—Jš�œ�œ˜%Jš�œ�œ˜+Jš�œ
�œ˜)Jš�œ�œ˜+š�œ�œ
�˜Jš
œ!˜!J˜0Jšœ�œ
˜Jš�œ
˜—Jš�œ
˜—˜Jš
�˜š�œ�œ
�˜J˜!Jš�œ˜&—š�œ	�œ
�˜Jšœ�œ
˜
˜Jš
�˜J˜.J˜ Jš�œ
�œ˜(Jš�œ
˜—˜
Jš
�˜J˜Jš�œ�
œ/˜5Jš�œ
�œ˜(Jš�œ�œ˜.Jš�œ�œ˜&Jš�œ�œ˜,Jš�œ
˜—˜	Jš
�˜Jšœ�œ�
œ˜/J˜ š�œ�œ
�˜J˜.Jš�œ
˜—Jš�œ�œ˜*Jš�œ�œ˜,Jš�œ
�œ˜(Jš�œ�œ˜.Jš�œ�œ˜.Jš�œ�œ˜4Jš�œ�œ˜4Jš�œ�œ˜:Jš�œ�œ˜0Jš�œ�œ˜0Jš�œ�œ˜.Jš�œ�œ˜0Jš�œ
˜—˜Jš
�˜Jšœ�œ�
œ
˜*Jš�œ
�œ˜(Jš�œ
�œ˜"Jš�œ	�œ˜ Jš�œ
�œ˜(Jš�œ�œ˜*Jš�œ�œ˜&Jš�œ
˜—˜Jš
�˜Jšœ�œ�
œ˜-J˜%Jš�œ�œ˜&Jš�œ
˜—˜Jš
�˜Jšœ�œ�
œ˜.Jš�œ�œ˜*Jš�œ	�œ˜ Jš�œ
˜—˜Jš
�˜Jš�œ
�œ˜"J˜(J˜*Jš�œ
˜—˜
Jš
�˜Jšœ�œ�
œ˜+Jš�œ�œ˜$Jš�œ
˜—˜Jš
�˜J˜3J˜"Jš�œ�œ˜*Jš�œ�œ˜.Jš�œ�œ˜.Jš�œ�œ˜8Jš�œ�œ˜0Jš�œ�œ˜.Jš�œ�œ˜0Jš�œ
˜—˜Jš
�˜J˜3J˜%Jš�œ�œ˜.Jš�œ�œ˜&Jš�œ�œ˜.Jš�œ
˜—˜Jš
�˜Jšœ�œ�
œ˜+J˜$J˜$Jš�œ
˜—˜Jš
�˜J˜5J˜ J˜Jš�œ�œ˜&Jš�œ�œ˜$Jš�œ
˜—˜
Jš
�˜J˜5Jš�œ
˜—˜	Jš
�˜J˜2J˜ Jš�œ�œ˜0Jš�œ
˜—˜Jš
�˜Jš�œ
�œ˜(Jš�œ	�œ˜ Jš�œ
˜—Jš�œ
˜—Jš�œ
˜—Jš�œ
˜—š�œ�˜Jš
�˜Jš�œ�œ˜"Jš�œ�œ˜"Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ
�	œ$˜>Jš
�˜Jšœ�œ
�
œ
�œ
�œ	�œ
˜2J˜J˜Jšœ�
œÏc˜:Jšœ4�œ˜DJ˜Jšœ�œ�
œ˜,J˜J˜J˜Jš�œ�œ˜+Jš�œ�œ˜)Jš�œ
˜J˜—šžœ�œ
�	œ%˜?Jš
�˜J˜J˜J˜J˜˜-Jšœ�œ
˜—J˜Jšœ�œ�
œ˜4Jš�œ�
œ&˜,J˜ Jš�œ�œ˜.š�œ�˜Jš
�˜š�œ�œ
�˜˜
Jš
�˜Jš
œ)˜)Jš�œ
˜—˜Jš
�˜J˜*Jš�œ
˜—˜Jš
�˜J˜J˜9J˜J˜Jš�œ�œ˜%Jš�œ
�œ˜)Jš�œ�œ˜-Jš�œ�œ˜#Jš�œ
˜—Jš�œ
˜—Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ
�	œ$˜>Jš
�˜J˜J˜J˜J˜˜+Jšœ�œ˜—J˜Jšœ�œ�
œ˜2Jš�œ�œ˜0š
�˜Jš
�˜Jš�œ�
œ˜Jšœ
�œ�œ
�œ˜GJš�œ
˜—J˜/J˜0J˜J˜%J˜š�œ
�œ
�˜˜Jš
�˜J˜BJ˜J˜#Jš�œ
˜—˜Jš
�˜Jšœ �œ�
œ˜-J˜%J˜$Jš�œ
˜—Jš�œ
˜—š�œ	�œ
�˜˜Jš
�˜Jšœ-�œ�
œ˜:š�œ�œ˜J˜$J˜5—J˜"J˜(š�œ�œ
�˜J˜/J˜-Jš�œ
˜Jš�œ�œ˜(—Jš�œ�œ˜.Jš�œ�œ˜*Jš�œ
�œ˜,Jš�œ
�œ˜&Jš�œ
�œ˜,Jš�œ�œ˜*Jš�œ�œ˜6Jš�œ�œ˜2Jš�œ
˜—˜Jš
�˜Jšœ-�œ�
œ˜AJš�œ
˜—Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ
�	œ$˜>Jš
�˜J˜J˜J˜J˜˜,Jšœ�œ˜—J˜Jšœ�œ�
œ6˜NJ˜!J˜ J˜&J˜:J˜#Jš�œ�œ˜&Jš�œ�œ˜*Jš�œ
˜J˜—šž
œ�œ
�	œ+˜GJš
�˜Jš	œ�œ
�œ�œ
�œ˜š
œ˜Jš
œY˜Y—Jšœ	�œ˜Jš
�˜Jš�œ
˜J˜—Jš�œ
˜—J˜—…—*¾8Ã