Alloc USING [AddNotify, Base, DropNotify, Handle, Index, Notifier, Top],

MobDefs USING [Link, VersionStamp],

CompilerUtil USING [AcquireStream, ReleaseStream],

ConvertUnsafe USING [SubString, ToRope],

IO USING [Put1, PutChar, PutF1, PutRope, STREAM],

Literals USING [Base, LitDescriptor, LitClass, LTIndex, ltType],

LiteralOps USING [DescriptorValue, IsShort, MasterString, StringValue, Value, ValueBits, ValueInt, ValueReal],

MessageTab USING [ModePrintName, NodePrintName, TypePrintName],

MimData USING [wordAlignment],

Rope USING [ROPE],

Symbols USING [Base, BitAddress, bodyType, BTIndex, CSEIndex, CTXFirst, CTXIndex, CTXNull, CTXRecord, ctxType, ISEIndex, lG, lZ, mdType, Name, nullName, RootBti, SEIndex, SENull, SERecord, seType, TransferMode, TypeClass, typeTYPE],

SymbolOps USING [CtxLevel, DecodeBitAddr, DecodeCard, DecodeInt, DecodeLink, DecodeType, EnumerateBodies, FindExtension, NameForSe, NextSe, own, SubStringForName, TypeLink, XferMode],

Table USING [IndexRep],

Target: TYPE MachineParms USING [bitOrder, bitsPerByte, bitsPerLongWord],

Tree USING [Base, Index, Link, NodeName, Scan, nullIndex, nullInfo, treeType],

TreeOps USING [GetNode, GetTag, ScanSons];

IF prefix # NIL THEN IO.PutRope[errorStream, prefix];

IO.PutRope[errorStream, IF b THEN "TRUE" ELSE "FALSE"];

};

IO.PutChar[errorStream, c];

};

IO.PutRope[errorStream, r];

};

IO.PutF1[errorStream, r, [integer[n]] ];

};

IO.PutF1[errorStream, r, [cardinal[c]] ];

};

IO.Put1[errorStream, [integer[n]]];

};

IF n > 2 THEN THROUGH [2..n) DO WriteChar['\n]; ENDLOOP;

IF n > 1 THEN WriteChar['\n];

WriteChar['\n];

};

NewLine[];

THROUGH [1..n/8] DO WriteRope[" "] ENDLOOP;

THROUGH [1..n MOD 8] DO WriteChar[' ] ENDLOOP;

};

table.AddNotify[DebugNotify];

IF st # NIL

definitionsOnly ¬ FALSE;

};

definitionsOnly ¬ FALSE;

IF logStream # NIL THEN CompilerUtil.ReleaseStream[log];

errorStream ¬ oldStream;

oldStream ¬ NIL;

logStream ¬ NIL;

table.DropNotify[DebugNotify];

};

lti: Literals.LTIndex = t.index;

IF LiteralOps.IsShort[lti]

};

s: LONG STRING = LiteralOps.StringValue[t.index];

WriteChar['"];

FOR i: CARDINAL IN [0..s.length) DO WriteChar[s[i]] ENDLOOP;

WriteChar['"];

IF t.index # LiteralOps.MasterString[t.index] THEN WriteChar['L];

};

IO.PutRope[errorStream, MessageTab.NodePrintName[n]];

};

OPEN Tree;

Printer: Tree.Scan = {

Printer[t];

};

Enter[table];

PrintSubTree[root, 0];

NewLine[2];

Exit[table];

};

Enter[table];

[] ¬ SymbolOps.EnumerateBodies[SymbolOps.own, RootBti, PrintBody];

NewLine[];

Exit[table];

};

OPEN body: bb[bti];

WriteRope["Body: "];

WITH b: body SELECT FROM

Indent[2];

PrintIndex["context: ", body.localCtx];

WriteRopeInt[", level: %g", body.level];

WITH body.info SELECT FROM

NewLine[2];

RETURN [FALSE];

};

ctx: CTXIndex;

limit: CTXIndex;

Enter[table];

definitionsOnly ¬ definitions; -- must be after Enter

limit ¬ table.Top[Symbols.ctxType];

ctx ¬ CTXFirst + CTXRecord.nil.SIZE;

UNTIL ctx = limit DO

NewLine[];

Exit[table];

};

sei, root: ISEIndex;

PrintIndex["Context: ", ctx];

IF SymbolOps.CtxLevel[SymbolOps.own, ctx] # lZ THEN

WITH c: ctxb[ctx] SELECT FROM

root ¬ sei ¬ ctxb[ctx].seList;

DO

};

sep: LONG POINTER TO SERecord.id = @seb[sei];

typeSei: SEIndex;

Indent[nBlanks];

PrintSei[NIL, sei];

PrintIndex[" [", sei]; WriteChar[']];

IF sep.public THEN WriteRope[" [public]"];

IF sep.mark3 THEN {

};

IF prefix # NIL THEN WriteRope[prefix];

IF name = nullName

};

PrintName[prefix, SymbolOps.NameForSe[SymbolOps.own, sei]];

};

IO.PutRope[errorStream, MessageTab.TypePrintName[n]];

};

IO.PutRope[errorStream, MessageTab.ModePrintName[n]];

};

tSei: SEIndex;

IF prefix # NIL THEN WriteRope[ConvertUnsafe.ToRope[prefix]];

IF sei = SENull

PrintIndex[" [", sei];

WriteChar[']];

};

IF sei # SENull THEN {

};

WriteRope[prefix];

IF ctx = CTXNull THEN WriteRope[" ctx: NIL"] ELSE PrintIndex[" ctx: ", ctx];

};

WriteRope[prefix];

IF sei = SENull

};

tagged: Table.IndexRep ¬ LOOPHOLE[v];

int: INT ¬ LOOPHOLE[tagged];

WriteRope[prefix];

SELECT tagged.tag FROM

WriteInt[int];

};

SELECT link.tag FROM

WriteRopeInt["mod: %g", link.modIndex];

WriteRopeInt[", offset: %g]", link.offset];

};

stampWords: CARDINAL = MobDefs.VersionStamp.SIZE;

str: PACKED ARRAY [0..4*stampWords) OF [0..16) = LOOPHOLE[stamp];

digit: STRING = "0123456789abcdef"L;

WriteRope[prefix];

FOR i: NAT IN [0..4*stampWords) DO WriteChar[digit[str[i]]] ENDLOOP;

};>>

stampBytes: CARDINAL = BYTES[MobDefs.VersionStamp];

str: PACKED ARRAY [0..2*stampBytes) OF [0..16) = LOOPHOLE[stamp];

digit: STRING = "0123456789abcdef"L;

WriteRope[prefix];

FOR i: NAT IN [0..2*stampBytes) DO WriteChar[digit[str[i]]] ENDLOOP;

};