<<>>
<<ObjectOut.mesa>>
    <<Copyright Ó 1985, 1986, 1987, 1988, 1989, 1990, 1991 by Xerox Corporation.  All rights reserved.>>
    <<Satterthwaite, June 23, 1986 3:41:36 pm PDT>>
    <<Sweet, September 2, 1980  3:05 PM>>
    <<Russ Atkinson (RRA) January 23, 1990 1:13:35 pm PST>>
    <<JKF August 15, 1988 1:40:35 pm PDT>>
    <<Willie-s, September 24, 1991 2:20 pm PDT>>

        DIRECTORY
            Alloc USING [AddNotify, Base, Bias, Bounds, DropNotify, Handle, Notifier, Top],
            Basics USING [LowHalf, RawBytes],
            CompilerUtil USING [Address, FileByteIndex],
            ConvertUnsafe USING [AppendSubStringToRefText, SubString],
            FileParms USING [Name],
            IO USING [GetIndex, SetIndex, STREAM, UnsafeBlock, UnsafePutBlock],
            LiteralOps USING [CopyLiteral, CopyStringLiteral, ForgetEntries, StringValue, TextType],
            Literals USING [Base],
            MimData USING [codeSeg, compilerVersion, fgTable, fixupLoc, importCtx, interface, mainCtx, moduleCtx, mtRoot, mtRootSize, 
            objectVersion, ownSymbols, source, symSeg, typeAtomRecord],
            MimZones USING [permZone],
            MobDefs USING [FTNull, SGRecord, VersionStamp],
            OSMiscOps USING [Address, Copy, Fill, FreeUnits, Units],
            RCMap USING [Base],
            RCMapOps USING [Acquire, Create, Destroy, GetSpan, RCMT],
            Rope USING [Flatten, Length, Text, TextRep],
            RTMob USING [AnyStamp, RefLitItem, RefLitList, RTHeader, StampIndex, StampList, TypeItem, TypeList, UTInfo],
            SymbolOps USING [HashBlock, SubStringForName],
            Symbols USING [Base, HashVector, MDIndex, MDNull, Name, OwnMdi, Type],
            SymbolSegment USING [Base, bodyType, constType, ctxType, ExtFirst, ExtIndex, ExtRecord, extType, FGHeader, FGTEntry, htType, 
            ltType, mdType, seType, ssType, STHeader, stType, VersionID, WordOffset],
            SymLiteralOps USING [DescribeRefLits, DescribeTypes, EnumerateRefLits, EnumerateTypes, RefLitItem, RefLitsVisitor, TypeIndex, 
            TypesVisitor, UTypeId],
            Table USING [IPointer, Selector, Tag],
            Tree USING [Base, firstIndex, Index, Link, Map, Node, Null, treeTag, treeType],
            TreeOps USING [FreeTree, GetTag, UpdateLeaves],
            TypeStrings USING [Create],
            UnsafeStorage USING [GetSystemUZone];
ObjectOut: PROGRAM
    IMPORTS Alloc, Basics, ConvertUnsafe, IO, LiteralOps, MimData, MimZones, OSMiscOps, RCMapOps, Rope, SymbolOps, SymLiteralOps, 
    TreeOps, TypeStrings, UnsafeStorage
    EXPORTS CompilerUtil
    SHARES Rope
    = {

    STREAM: TYPE = IO.STREAM;

    FileByteIndex: TYPE = CompilerUtil.FileByteIndex;
        <<also see Pass4B.mesa>>
    StreamIndex: TYPE = FileByteIndex;
    Address: TYPE = CompilerUtil.Address;

    stream: STREAM Ź NIL;
    padding: IO.UnsafeBlock Ź [NIL, 0, 0];
    zone: UNCOUNTED ZONE = UnsafeStorage.GetSystemUZone[];

    bytesPerCARD: NAT = BYTES[CARD];
    bytesPerUnit: NAT = BYTES[UNIT];
    bytesPerPage: NAT = 16;
        <<An arbitrary power of 2 (at least as large as bytesPerCARD), historically required to be an actual file page, but no longer so 
        constrained.>>
    unitsPerPage: NAT = bytesPerPage / bytesPerUnit;
    unitsPerCARD: NAT = bytesPerCARD / bytesPerUnit;

    unitsPerWord: NAT = UNITS[WORD];

    TextScratch: TYPE = ARRAY [0..240) OF WORD;
    textScratch: REF TextScratch = MimZones.permZone.NEW[TextScratch];

    StringHeaderKludge: TYPE = MACHINE DEPENDENT RECORD [len, max: CARD16];
    StringHeaderStringBodyCheck: NAT[0..0] =
    SIZE[StringHeaderKludge] - SIZE[StringBody[0]];
    StringHeaderKludgeCheck: NAT[0..0] =
    SIZE[SymbolSegment.FGHeader[0]] - SIZE[SymbolSegment.WordOffset] - SIZE[StringHeaderKludge];
        <<RRA: The above static checks are to ensure congruence of sizes (at least) between the string header in the FGHeader and as 
        declared in StringHeaderKludge and in the built-in StringBody.>>

    RoundUpBytes: PROC [bytes: INT] RETURNS [INT] = INLINE {
        IF bytesPerCARD # 1 THEN {
            mod: CARDINAL = Basics.LowHalf[bytes] MOD bytesPerCARD;
            IF mod # 0 THEN bytes Ź bytes + (bytesPerCARD-mod);
            };
        RETURN [bytes];
        };

    RoundUpUnits: PROC [units: INT] RETURNS [INT] = INLINE {
        IF unitsPerCARD # 1 THEN {
            mod: CARDINAL = Basics.LowHalf[units] MOD unitsPerCARD;
            IF mod # 0 THEN units Ź units + (unitsPerCARD-mod);
            };
        RETURN [units];
        };

    RoundDownBytes: PROC [bytes: INT] RETURNS [INT] = INLINE {
        IF bytesPerCARD # 1 THEN {
            mod: CARDINAL = Basics.LowHalf[bytes] MOD bytesPerCARD;
            IF mod # 0 THEN bytes Ź bytes - mod;
            };
        RETURN [bytes];
        };

    treeTag: Table.Tag = Tree.treeTag;

    Suspect: SIGNAL = CODE;
    testMod: BOOL Ź TRUE;
    testLen: BOOL Ź TRUE;

    PutBytes: PROC [block: IO.UnsafeBlock, pad: BOOL Ź FALSE] = {
        index: CARD = IO.GetIndex[stream];
        rem: CARDINAL Ź index MOD bytesPerPage;
        IF testMod AND (rem MOD bytesPerCARD) # 0 THEN SIGNAL Suspect;
        IF block.count # 0 THEN IO.UnsafePutBlock[stream, block];
        rem Ź Basics.LowHalf[block.count] MOD bytesPerCARD;
        SELECT TRUE FROM
            rem = 0 => {};
            pad => {
                <<We are requested to pad out to a 32-bit boundary>>
                padding.count Ź bytesPerCARD-rem;
                IO.UnsafePutBlock[stream, padding];
                };
            testLen => SIGNAL Suspect;
            ENDCASE;
        };

    NextFilePage: PROC RETURNS [CARD] = {
        index: CARD Ź IO.GetIndex[stream];
        rem: CARD = index MOD bytesPerPage;
        IF rem # 0 THEN {
            delta: NAT Ź bytesPerPage - rem;
            padding.count Ź delta;
            index Ź index + delta;
            PutBytes[padding];
            };
        RETURN [index];
        };

    WriteObjectUnits: PROC [addr: Address, n: CARD] = {
        PutBytes[[base: LOOPHOLE[addr], startIndex: 0, count: n*bytesPerUnit]];
        };

    RewriteObjectUnits: PROC [index: StreamIndex, addr: Address, n: CARD] = {
        saveIndex: StreamIndex = stream.GetIndex[];
        stream.SetIndex[index];
        PutBytes[[LOOPHOLE[addr], 0, n*bytesPerUnit]];
        stream.SetIndex[saveIndex];
        };

    WriteTableBlock: PROC [p: Table.IPointer, size: CARD] = {
        WriteObjectUnits[LOOPHOLE[p], size];
        };

    <<mob i/o>>

        mobOffset: CARD Ź 0;
            <<offset in file in bytes from the start>>
        mobIndex: FileByteIndex Ź 0;
            <<the starting stream index>>

        MobIndex: PROC [offset: CARD] RETURNS [FileByteIndex] = INLINE {
            RETURN [mobIndex + offset];
            };

        StartMob: PUBLIC PROC = {
            [] Ź NextFilePage[];
            mobIndex Ź stream.GetIndex[];
            mobOffset Ź 0;
            };

        ReadMobOffset: PUBLIC PROC RETURNS [CARD] = {
            <<This is presumed to be in addressing units.>>
            RETURN [mobOffset / bytesPerUnit];
            };

        ReadMobIndex: PUBLIC PROC RETURNS [StreamIndex] = {
            <<This is presumed to be in bytes.>>
            RETURN [MobIndex[mobOffset]];
            };

        AppendMobCard: PUBLIC PROC [word: CARD] = {
            <<Workaround for Mimosa bug:>>
            Long: PROC [p: LONG POINTER] RETURNS [LONG POINTER] = {RETURN[p]};
            IF IO.GetIndex[stream] MOD bytesPerCARD # 0 THEN ERROR;
                <<RRA: Eventually we can flush this check>>
            PutBytes[[base: LOOPHOLE[Long[@word]], startIndex: 0, count: bytesPerCARD]];
            mobOffset Ź mobOffset + bytesPerCARD;
            };

        AppendMobPair: PUBLIC PROC [first: CARD16, second: CARD16] = {
            Pair: TYPE = MACHINE DEPENDENT RECORD [first: CARD16, second: CARD16];
                bpp: NAT = BYTES[Pair];
            <<Workaround for Mimosa bug:>>
            Long: PROC [p: LONG POINTER] RETURNS [LONG POINTER] = {RETURN[p]};
            pair: Pair Ź [first: first, second: second];
            IF IO.GetIndex[stream] MOD bytesPerCARD # 0 THEN ERROR;
                <<RRA: Eventually we can flush this check>>
            PutBytes[[base: LOOPHOLE[Long[@pair]], startIndex: 0, count: bpp]];
            mobOffset Ź mobOffset + bpp;
            };

        AppendMobUnits: PUBLIC PROC [addr: Address, n: CARD] = {
            WriteObjectUnits[addr, n];
            mobOffset Ź mobOffset + n*bytesPerUnit;
            };

        AppendMobString: PUBLIC PROC [s: LONG STRING] = {
            len: CARDINAL = s.length;
            max: CARDINAL = RoundUpBytes[len];
            header: StringHeaderKludge Ź [len, max];
            AppendMobUnits[@header, StringHeaderKludge.SIZE];
            AppendMobUnits[@s.text, StringBody[max].SIZE - StringBody[0].SIZE];
            };

        FillMobPage: PUBLIC PROC = {
            rem: CARDINAL = mobOffset MOD bytesPerPage;
            IF rem # 0 THEN {
                [] Ź NextFilePage[];
                mobOffset Ź mobOffset + (bytesPerPage - rem);
                };
            };

        UpdateMobUnits: PUBLIC PROC [index: FileByteIndex, addr: Address, n: CARD] = {
            RewriteObjectUnits[index, addr, n];
            };

        EndMob: PUBLIC PROC = {
            [] Ź NextFilePage[];
            };

    <<symbol table i/o >>

        SetFgt: PROC [d: SymbolSegment.WordOffset, sourceFile: FileParms.Name]
        RETURNS [fgBase, fgBytes: CARD Ź 0] = {
            nu: INT = d;
            MimData.symSeg.units.units Ź d;
            IF MimData.interface
                THEN {
                    MimData.symSeg.extraUnits.units Ź 0;
                    MimData.codeSeg.file Ź MobDefs.FTNull;
                    MimData.codeSeg.base.units Ź 0;
                    MimData.codeSeg.units.units Ź 0;
                    MimData.mtRoot.framesize Ź 0;
                    }
                ELSE { 
                    max: INT = RoundUpBytes[Rope.Length[sourceFile]];
                    len: CARD = SymbolSegment.FGHeader[max].SIZE + MimData.fgTable.LENGTH*SymbolSegment.FGTEntry.SIZE;
                    fgBase Ź nu;
                    fgBytes Ź bytesPerUnit * len;
                    MimData.symSeg.extraUnits.units Ź len;
                    };
            MimData.codeSeg.class Ź code;
            MimData.codeSeg.extraUnits.units Ź 0;
            };

    <<tree i/o>>

        ltBias: CARD Ź 0;
        stBias: CARD Ź 0;

        WriteExtensions: PROC [table: Alloc.Handle] RETURNS [size: CARD] = {
            tb: Tree.Base;
            ltb: Literals.Base;    -- output literal table base
            stb: Literals.Base;    -- output string table base
            treeLoc: Tree.Index Ź Tree.firstIndex;
            initialized: BOOL Ź FALSE;    -- set after rep of Tree.Null is written
            OutputNotify: Alloc.Notifier = {
                tb Ź base[Tree.treeType];
                ltb Ź base[SymbolSegment.ltType];
                stb Ź base[SymbolSegment.stType];
                seb Ź base[SymbolSegment.seType];
                ctxb Ź base[SymbolSegment.ctxType];
                extb Ź base[SymbolSegment.extType];
                };
            OutputLiteral: PROC [t: Tree.Link.literal] RETURNS [Tree.Link] = {
                t.index Ź LiteralOps.CopyLiteral[[baseP: @ltb, index: t.index]]-ltBias;
                RETURN [t];
                };
            OutputString: PROC [t: Tree.Link.string] RETURNS [Tree.Link] = {
                t.index Ź LiteralOps.CopyStringLiteral[baseP: @stb, index: t.index]-stBias;
                    <<do we really want to use a string bias here?>>
                RETURN [t];
                };
            SetEmpty: Tree.Map = {RETURN [Tree.Null]};
            OutputTree: Tree.Map = {
                WITH link: t SELECT TreeOps.GetTag[t] FROM
                    literal => v Ź OutputLiteral[link];
                    string => v Ź OutputString[link];
                    subtree => {
                        s: Tree.Link = TreeOps.UpdateLeaves[link, OutputTree];
                        IF s = Tree.Null AND initialized
                            THEN v Ź Tree.Null
                            ELSE
                                WITH s SELECT TreeOps.GetTag[s] FROM
                                    subtree => {
                                        node: Tree.Index = index;
                                        units: CARD = Tree.Node[tb[node].nSons].SIZE;
                                        WriteTableBlock[@tb[node], units];    -- common header
                                        [] Ź TreeOps.FreeTree[TreeOps.UpdateLeaves[s, SetEmpty]];
                                        v Ź [subtree[index: treeLoc]];
                                        treeLoc Ź treeLoc + units;
                                        };
                                    ENDCASE => v Ź s;
                        };
                    ENDCASE => v Ź link;
                };
            extb: SymbolSegment.Base;
            extLimit: SymbolSegment.ExtIndex;
            seb, ctxb: Symbols.Base;
            table.AddNotify[OutputNotify];
            [] Ź OutputTree[Tree.Null];
            initialized Ź TRUE;
            extb Ź table.Bounds[SymbolSegment.extType].base;
            extLimit Ź table.Top[SymbolSegment.extType];
            FOR exti: SymbolSegment.ExtIndex Ź SymbolSegment.ExtFirst,
            exti + SymbolSegment.ExtRecord.SIZE
            UNTIL exti = extLimit DO
                extb[exti].tree Ź
                    IF MimData.interface OR extb[exti].type = value OR extb[exti].type = default
                        THEN OutputTree[extb[exti].tree]
                        ELSE Tree.Null;
                ENDLOOP;
            table.DropNotify[OutputNotify];
            RETURN [treeLoc-Tree.firstIndex];
            };

        WriteExtensionTable: PROC [table: Alloc.Handle] RETURNS [CARD] = {
            extb: SymbolSegment.Base Ź NIL;
            extLimit: SymbolSegment.ExtIndex Ź table.Top[SymbolSegment.extType];
            OutputNotify: Alloc.Notifier = {extb Ź base[SymbolSegment.extType]};
            size: CARD Ź 0;
            table.AddNotify[OutputNotify];
            FOR exti: SymbolSegment.ExtIndex Ź SymbolSegment.ExtFirst,
            exti + SymbolSegment.ExtRecord.SIZE
            UNTIL exti = extLimit DO
                IF extb[exti].tree # Tree.Null THEN {
                    size Ź size + SymbolSegment.ExtRecord.SIZE;
                    WriteTableBlock[@extb[exti], SymbolSegment.ExtRecord.SIZE];
                    };
                ENDLOOP;
            table.DropNotify[OutputNotify];
            RETURN [size];
            };

    <<package table i/o>>

        <<
            RRA: Obsolete, November 21, 1989 10:13:59 pm PST
        WritePackTables: PROC [table: Alloc.Handle] = {
            nOuter: CARDINAL = MimData.nBodies - MimData.nInnerBodies;
            IF nOuter # 0 THEN {
                OutputNotify: Alloc.Notifier = {bb Ź base[SymbolSegment.bodyType]};
                BodyLength: PROC [info: Symbols.BodyInfo] RETURNS [CARDINAL] = INLINE {
                    RETURN [WITH info SELECT FROM External => bytes, ENDCASE => 0];
                    };
                OuterBody: PROC [bti: Symbols.BTIndex] = {
                    WITH body: bb[bti] SELECT FROM
                        Callable =>
                            IF ~body.inline THEN {
                                outer[next] Ź PackageSymbols.OuterPackRecord[
                                    hti: SymbolOps.NameForSe[MimData.ownSymbols, body.id],
                                    entryIndex: body.entryIndex,
                                    length: BodyLength[body.info],
                                    firstSon: InnerBodies[bti],
                                    resident: body.resident];
                                next Ź next + 1;
                                };
                        ENDCASE
                    };
                InnerBodies: PROC [root: Symbols.BTIndex] RETURNS [origin: PackageSymbols.IPIndex] = {
                    ProcessBody: PROC [bti: Symbols.BTIndex] RETURNS [BOOL] = {
                        WITH body: bb[bti] SELECT FROM
                            Callable =>
                                IF ~body.inline AND body.level > Symbols.lL THEN {
                                    IF origin # PackageSymbols.IPNull THEN
                                        WriteObjectUnits[@buffer, PackageSymbols.InnerPackRecord.SIZE];
                                    buffer Ź PackageSymbols.InnerPackRecord[
                                        entryIndex: body.entryIndex,
                                        length: BodyLength[body.info],
                                        lastSon: FALSE];
                                    IF origin = PackageSymbols.IPNull THEN origin Ź nextIP;
                                    nextIP Ź nextIP + 1;
                                    };
                            ENDCASE => NULL;
                        RETURN [FALSE];
                        };
                    buffer: PackageSymbols.InnerPackRecord;
                    origin Ź PackageSymbols.IPNull;
                    IF root # Symbols.RootBti
                        THEN [] Ź SymbolOps.EnumerateBodies[MimData.ownSymbols, root, ProcessBody]
                        ELSE
                            FOR sonBti: Symbols.BTIndex Ź SymbolOps.SonBti[MimData.ownSymbols, root], SymbolOps.SiblingBti[MimData.ownSymbols, sonBti]
                                UNTIL sonBti = Symbols.BTNull DO
                                    WITH body: bb[sonBti] SELECT FROM
                                        Callable => NULL;    -- processed as an outer body
                                        ENDCASE => [] Ź SymbolOps.EnumerateBodies[
                                        MimData.ownSymbols, sonBti, ProcessBody];
                                    ENDLOOP;
                    IF origin # PackageSymbols.IPNull THEN {
                        buffer.lastSon Ź TRUE;
                        WriteObjectUnits[@buffer, PackageSymbols.InnerPackRecord.SIZE];
                        };
                    };
                bb: Symbols.Base Ź NIL;
                outer: REF OuterPackRecordSeq Ź MimZones.tempZone.NEW[OuterPackRecordSeq[nOuter]];
                outerPtr: LONG POINTER TO PackageSymbols.OuterPackRecord = @outer[0];
                outerDesc: PackDescriptor = DESCRIPTOR[outerPtr, nOuter];
                next: CARDINAL Ź 0;
                nextIP: PackageSymbols.IPIndex Ź PackageSymbols.IPIndex.FIRST;

                table.AddNotify[OutputNotify];
                OuterBody[Symbols.RootBti];
                FOR bti: Symbols.BTIndex Ź SymbolOps.SonBti[MimData.ownSymbols, Symbols.RootBti], SymbolOps.SiblingBti[MimData.ownSymbols, bti]
                UNTIL bti = Symbols.BTNull DO
                    OuterBody[bti];
                    ENDLOOP;
                table.DropNotify[OutputNotify];
                IF next # nOuter OR nextIP # MimData.nInnerBodies THEN ERROR;
                SortPackInfo[outerDesc, 1, nOuter];
                WriteObjectUnits[outerPtr, nOuter*PackageSymbols.OuterPackRecord.SIZE];
                MimZones.tempZone.FREE[@outer];
                };
            };

        PackDescriptor: TYPE = LONG DESCRIPTOR FOR ARRAY OF PackageSymbols.OuterPackRecord;
        OuterPackRecordSeq: TYPE = RECORD [
            SEQUENCE len: NAT OF PackageSymbols.OuterPackRecord
            ];
        SortPackInfo: PROC [a: PackDescriptor, l, u: CARDINAL] = {
            <<Shell sort of a[l..u)>>
            h: CARDINAL Ź u - l;
            DO
                h Ź h/2;
                FOR k: CARDINAL IN [l+h .. u) DO
                    i: CARDINAL Ź k;
                    j: CARDINAL Ź k-h;
                    key: Symbols.Name Ź a[k].hti;
                    t: PackageSymbols.OuterPackRecord Ź a[k];
                    WHILE LOOPHOLE[key, CARD] < LOOPHOLE[a[j].hti, CARD] DO
                        a[i] Ź a[j];
                        i Ź j;
                        IF j < l+h THEN EXIT;
                        j Ź j-h;
                        ENDLOOP;
                    a[i] Ź t;
                    ENDLOOP;
                IF h <= 1 THEN EXIT;
                ENDLOOP
            };>>

    <<main drivers>>

        StartObjectFile: PUBLIC PROC [objectStream: STREAM] = {
            stream Ź objectStream;
            padding Ź [
            base: LOOPHOLE[zone.NEW[Basics.RawBytes[bytesPerPage]]],
            startIndex: 0,
            count: bytesPerPage];
            OSMiscOps.Fill[padding.base, WORDS[Basics.RawBytes[bytesPerPage]], 0];
            };

        TableOut: PUBLIC PROC [table: Alloc.Handle] = {
            h: SymbolSegment.STHeader;
            fixupLoc: StreamIndex;
            d: SymbolSegment.WordOffset;
            units: CARD;
            WriteSubTable: PROC [selector: Table.Selector] = {
                base: Alloc.Base;
                size: CARD;
                [base, size] Ź RoundedBounds[selector];
                WriteTableBlock[base + table.Bias[selector], size];
                };
            RoundedBounds: PROC [selector: Table.Selector] RETURNS [base: Alloc.Base, size: CARD] = {
                [base, size] Ź Alloc.Bounds[table, selector];
                IF unitsPerCARD # 1 THEN {
                    rem: CARDINAL Ź size MOD unitsPerCARD;
                    IF rem # 0 THEN size Ź size + (unitsPerCARD - rem);
                    };
                RETURN [base, size];
                };
            MimData.symSeg.class Ź symbols;
            MimData.symSeg.base.units Ź NextFilePage[] / bytesPerUnit;
            h.versionIdent Ź SymbolSegment.VersionID;
            h.version Ź MimData.objectVersion;
            h.sourceVersion Ź MimData.source.version;
            h.creator Ź MimData.compilerVersion;
            h.definitionsFile Ź MimData.interface;
            h.extended Ź TRUE;
            h.directoryCtx Ź MimData.moduleCtx;
            h.importCtx Ź MimData.importCtx;
            h.outerCtx Ź MimData.mainCtx;
            d Ź SymbolSegment.STHeader.SIZE;
            h.hvBlock.offset Ź d;
            d Ź d + (h.hvBlock.size Ź Symbols.HashVector.SIZE);
            h.htBlock.offset Ź d;
            d Ź d + (h.htBlock.size Ź RoundedBounds[SymbolSegment.htType].size);
            h.ssBlock.offset Ź d;
            d Ź d + (h.ssBlock.size Ź RoundedBounds[SymbolSegment.ssType].size);
            h.innerPackBlock Ź h.outerPackBlock Ź [d, 0];
            <<    RRA: Obsolete, November 21, 1989 10:17:51 pm PST
                IF NOT MimData.interface THEN {
                    h.innerPackBlock.offset Ź d;
                    d Ź d + (h.innerPackBlock.size Ź MimData.nInnerBodies*PackageSymbols.InnerPackRecord.SIZE);
                    h.outerPackBlock.offset Ź d;
                    d Ź d + (h.outerPackBlock.size Ź
                        (MimData.nBodies-MimData.nInnerBodies)*PackageSymbols.OuterPackRecord.SIZE);
                    };
                    >>
            h.constBlock.offset Ź d;
             d Ź d + (h.constBlock.size Ź RoundedBounds[SymbolSegment.constType].size);
            h.seBlock.offset Ź d;
             d Ź d + (h.seBlock.size Ź RoundedBounds[SymbolSegment.seType].size);
            h.ctxBlock.offset Ź d;
             d Ź d + (h.ctxBlock.size Ź RoundedBounds[SymbolSegment.ctxType].size);  
            h.mdBlock.offset Ź d;
            d Ź d + (h.mdBlock.size Ź RoundedBounds[SymbolSegment.mdType].size);
            h.bodyBlock.offset Ź d;
            d Ź d + (h.bodyBlock.size Ź RoundedBounds[SymbolSegment.bodyType].size);
            <<h.bodyBlock.size _ MimData.defBodyLimit;>>
                <<RRA sez: what the hell was this for?  An xref of the compiler and binder revealed no clients, and the whole bodyBlock gets 
                written anyway!  This caused confusion to MobMapperImpl, you bet!  Many of the INLINE bodies were omitted!  March 
                20, 1989.>>
            h.epMapBlock Ź h.spareBlock Ź [d, 0];
            IF RoundedBounds[SymbolSegment.extType].size # 0
                THEN fixupLoc Ź stream.GetIndex[]
                ELSE {
                    h.treeBlock Ź h.litBlock Ź h.sLitBlock Ź h.extBlock Ź [d, 0];
                    [h.fgRelBase, h.fgCount] Ź SetFgt[d, MimData.source.locator];
                    };
            WriteObjectUnits[@h, SymbolSegment.STHeader.SIZE];
            WriteObjectUnits[SymbolOps.HashBlock[], h.hvBlock.size];
            WriteSubTable[SymbolSegment.htType];
            WriteSubTable[SymbolSegment.ssType];
            <<IF ~MimData.interface THEN WritePackTables[table];>>
            WriteSubTable[SymbolSegment.constType];
            WriteSubTable[SymbolSegment.seType];
            WriteSubTable[SymbolSegment.ctxType];
            WriteSubTable[SymbolSegment.mdType];
            WriteSubTable[SymbolSegment.bodyType];
            IF RoundedBounds[SymbolSegment.extType].size # 0 THEN {
                [ltBias, stBias] Ź LiteralOps.ForgetEntries[];
                h.treeBlock.offset Ź d;
                h.treeBlock.size Ź WriteExtensions[table];
                d Ź d + h.treeBlock.size;

                <<Write out the literal table>>
                h.litBlock.offset Ź d;
                h.litBlock.size Ź units Ź RoundedBounds[SymbolSegment.ltType].size - ltBias;
                WriteTableBlock[RoundedBounds[SymbolSegment.ltType].base + table.Bias[SymbolSegment.ltType] + ltBias, units];
                d Ź d + units;

                <<Write out the string literal table>>
                h.sLitBlock.offset Ź d;
                h.sLitBlock.size Ź units Ź RoundedBounds[SymbolSegment.stType].size - stBias;
                WriteTableBlock[RoundedBounds[SymbolSegment.stType].base + table.Bias[SymbolSegment.stType] + stBias, units];
                d Ź d + units;

                <<Write out the extension table>>
                h.extBlock.offset Ź d;
                h.extBlock.size Ź WriteExtensionTable[table];
                d Ź d + h.extBlock.size;
                [h.fgRelBase, h.fgCount] Ź SetFgt[d, MimData.source.locator];
                RewriteObjectUnits[fixupLoc, @h, SymbolSegment.STHeader.SIZE];
                };
            IF ~MimData.interface THEN {
                r: Rope.Text = Rope.Flatten[MimData.source.locator];
                p: LONG POINTER = LOOPHOLE[r, LONG POINTER] + SIZE[Rope.TextRep[0]];
                len: NAT = r.length;
                max: NAT = RoundUpBytes[len];
                offset: CARD Ź SymbolSegment.FGHeader[0].SIZE + units;
                pair: StringHeaderKludge Ź [len, max];
                [] Ź NextFilePage[];
                units Ź max/bytesPerUnit;
                WriteObjectUnits[@offset, SymbolSegment.WordOffset.SIZE];
                WriteObjectUnits[@pair, StringHeaderKludge.SIZE];
                PutBytes [block: [base: p, startIndex: 0, count: len], pad: TRUE];
                WriteObjectUnits[MimData.fgTable.BASE, MimData.fgTable.LENGTH*SymbolSegment.FGTEntry.SIZE];
                OSMiscOps.FreeUnits[MimData.fgTable.BASE];
                }
            };

        RTTableOut: PUBLIC PROC [table: Alloc.Handle] = {
            nLits: CARDINAL = SymLiteralOps.DescribeRefLits[].length;
            nTypes: CARDINAL = SymLiteralOps.DescribeTypes[].length;
            IF nLits + nTypes # 0 THEN {
                OPEN RTMob;
                EqText: PROC [rt: REF TEXT, pt: LONG POINTER TO TEXT] RETURNS [BOOL] = INLINE {
                    IF rt.length # pt.length THEN RETURN [FALSE];
                    FOR i: CARDINAL IN [0..rt.length) DO
                        IF rt[i] # pt[i] THEN RETURN [FALSE];
                        ENDLOOP;
                    RETURN [TRUE];
                    };
                EnterText: PROC [s: REF TEXT] RETURNS [loc: CARDINAL Ź 0] = {
                    t: LONG POINTER TO TEXT;
                    units: CARDINAL;
                    scratchSize: NAT = SIZE[TextScratch];
                    DO
                        IF loc >= textLoc THEN EXIT;
                        t Ź textBase + loc;
                        IF EqText[s, t] THEN RETURN;
                        loc Ź loc + RoundUpUnits[TEXT[t.length].SIZE];
                        ENDLOOP;
                    units Ź RoundUpUnits[TEXT[s.length].SIZE];
                    IF textBase = NIL AND units < scratchSize
                        THEN {
                            <<There is enough room in the scratch area to avoid expensive allocation>>
                            textBase Ź LOOPHOLE[textScratch];
                            textLimit Ź SIZE[TextScratch];
                            }
                        ELSE
                            WHILE (textLoc + units) > textLimit DO
                                newLimit: CARDINAL = SELECT textLimit FROM
                                    <= scratchSize => scratchSize+scratchSize,
                                    < (LAST[CARDINAL]-1024)/2 => textLimit+textLimit,
                                    < (LAST[CARDINAL]-1024) => LAST[CARDINAL]-512,
                                    ENDCASE => ERROR;
                                newBase: LONG POINTER = OSMiscOps.Units[newLimit];
                                IF textBase # NIL THEN {
                                    OSMiscOps.Copy[from: textBase, to: newBase, nwords: textLoc/unitsPerWord];
                                    IF textBase # LOOPHOLE[textScratch, LONG POINTER] THEN
                                        OSMiscOps.FreeUnits[textBase];
                                    };
                                textBase Ź newBase;
                                textLimit Ź newLimit;
                                ENDLOOP;
                    loc Ź textLoc;
                    OSMiscOps.Copy
                        [from: LOOPHOLE[s, LONG POINTER], to: textBase+loc, nwords: units/unitsPerWord];
                    textLoc Ź textLoc + units;
                    };
                EnterStamp: PROC [mdi: Symbols.MDIndex] RETURNS [index: RTMob.StampIndex] = {
                    IF mdi = Symbols.MDNull
                        THEN index Ź RTMob.AnyStamp
                        ELSE {
                            stamp: MobDefs.VersionStamp = table.Bounds[SymbolSegment.mdType].base[mdi].stamp;
                            FOR i: NAT IN [1 .. nextStamp) DO
                                IF stamp = stampList[i] THEN RETURN [[i]];
                                ENDLOOP;  
                            IF stampList = NIL OR nextStamp >= stampList.limit THEN ExpandStampList[];
                            index Ź [nextStamp];
                            stampList[nextStamp] Ź stamp;
                            nextStamp Ź nextStamp + 1;
                            };
                    };
                ExpandStampList: PROC = INLINE {
                    oldSize: NAT = nextStamp - 1;
                    AdjustStampList[oldSize + MAX[MIN[oldSize/2, 128], 32]];
                    };
                AdjustStampList: PROC [newSize: NAT] = {
                    oldSize: NAT = nextStamp - 1;
                    newList: REF RTMob.StampList = NEW[RTMob.StampList[newSize]];
                    FOR i: NAT IN [1 .. MIN[oldSize, newSize]] DO newList[i] Ź stampList[i] ENDLOOP;
                    stampList Ź newList;
                    };

                rtOffset: CARD Ź RTHeader.SIZE;
                header: RTHeader Ź [
                    refLitTable: LOOPHOLE[rtOffset],
                    litBase: LOOPHOLE[LONG[0]],
                    litLength: 0,
                    rcMapBase: LOOPHOLE[LONG[0]],
                    rcMapLength: 0,
                    stampTable: LOOPHOLE[LONG[0]],
                    typeTable: LOOPHOLE[rtOffset + RefLitList[nLits].SIZE]];
                fixupIndex: StreamIndex = ReadMobIndex[];
                textBase: LONG POINTER Ź NIL;  -- to a sequence of StringBody's
                textLimit: CARDINAL Ź 0;
                textLoc: CARDINAL Ź 0;
                stampList: REF RTMob.StampList Ź NIL;
                nextStamp: NAT Ź 1;

                AppendMobUnits[@header, RTHeader.SIZE];
                AppendMobPair[0, nLits];
                IF nLits # 0 THEN {
                    WriteLitItem: SymLiteralOps.RefLitsVisitor = {
                        info: RefLitItem;
                        loc, chars: CARDINAL;
                        referentType: Symbols.Type;
                        WITH v: item SELECT FROM
                            atom => {
                                desc: ConvertUnsafe.SubString Ź
                                SymbolOps.SubStringForName[MimData.ownSymbols, v.pName];
                                k: NAT Ź desc.length;
                                n: NAT Ź k + (bytesPerCARD - (k MOD bytesPerCARD));
                                s: REF TEXT Ź NEW[TEXT[n]];
                                ConvertUnsafe.AppendSubStringToRefText[s, desc];  
                                WHILE k < n DO s[k] Ź 0c; k Ź k + 1; ENDLOOP;
                                loc Ź EnterText[s];
                                chars Ź s.length;
                                referentType Ź MimData.typeAtomRecord;
                                s Ź NIL;
                                };
                            text => {
                                s: LONG STRING = LiteralOps.StringValue[v.value];
                                checkLoophole: NAT[0..0] = TEXT[0].SIZE - StringBody[0].SIZE;
                                loc Ź EnterText[LOOPHOLE[s, REF TEXT]];
                                chars Ź s.length;  -- ARRGGH
                                referentType Ź LiteralOps.TextType[v.value];
                                };
                            ENDCASE => ERROR;
                        info Ź [
                            referentType: SymLiteralOps.TypeIndex[referentType, FALSE],
                            offset: loc, length: RoundUpUnits[TEXT[chars].SIZE]];
                        AppendMobUnits[@info, RefLitItem.SIZE];
                        tl Ź tl + 1;
                        };
                    tl: NAT Ź 0;
                    SymLiteralOps.EnumerateRefLits[WriteLitItem];
                    IF tl # nLits THEN ERROR;
                        <<Sanity check>>
                    };

                AppendMobPair[0, nTypes];
                rtOffset Ź rtOffset + RefLitList[nLits].SIZE + TypeList[nTypes].SIZE;
                header.rcMapBase Ź LOOPHOLE[rtOffset];
                IF nTypes = 0
                    THEN header.rcMapLength Ź 0
                    ELSE {
                        rcmt: RCMapOps.RCMT = RCMapOps.Create[zone: zone, expansionOK: TRUE];
                        tc: NAT Ź 0;
                        EnterUT: PROC [type: Symbols.Type] RETURNS [RTMob.UTInfo] = {
                            mdi: Symbols.MDIndex;
                            sei: Symbols.Type;
                            [mdi, sei] Ź SymLiteralOps.UTypeId[type];
                            RETURN [[version: EnterStamp[mdi], sei: sei]];
                            };
                        WriteTypeItem: SymLiteralOps.TypesVisitor = {
                            s: LONG STRING Ź TypeStrings.Create[MimData.ownSymbols, type, zone];
                            info: TypeItem Ź [
                                table: MimData.mtRoot.sseg,
                                sei: type,
                                canonical: canonical,
                                rcMap: rcmt.Acquire[MimData.ownSymbols, type],
                                ct: [EnterText[LOOPHOLE[s, REF TEXT]]],  -- ARRGGH
                                ut: EnterUT[type]];
                            zone.FREE[@s];
                            AppendMobUnits[@info, TypeItem.SIZE];
                            tc Ź tc + 1;
                            };

                        [] Ź EnterStamp[Symbols.OwnMdi];
                        SymLiteralOps.EnumerateTypes[WriteTypeItem];
                        IF tc # nTypes THEN ERROR;
                            <<This should no longer happen!>>
                        header.rcMapLength Ź RoundUpUnits[rcmt.GetSpan[].size];
                        AppendMobUnits[rcmt.GetSpan[].base, header.rcMapLength];
                        rtOffset Ź rtOffset + header.rcMapLength;
                        [] Ź RCMapOps.Destroy[rcmt];
                        };
                header.stampTable Ź LOOPHOLE[rtOffset];
                AdjustStampList[nextStamp-1];
                AppendMobUnits[LOOPHOLE[stampList, LONG POINTER], StampList[nextStamp-1].SIZE];
                rtOffset Ź rtOffset + StampList[nextStamp-1].SIZE;
                stampList Ź NIL;
                header.litBase Ź LOOPHOLE[rtOffset];
                header.litLength Ź textLoc;
                IF textBase # NIL THEN {
                    AppendMobUnits[textBase, textLoc];
                    IF textBase # LOOPHOLE[textScratch, LONG POINTER] THEN
                        OSMiscOps.FreeUnits[textBase];
                    };
                UpdateMobUnits[fixupIndex, @header, RTHeader.SIZE];
                }
            };

        EndObjectFile: PUBLIC PROC [update: BOOL] = {
            IF stream # NIL AND update THEN {
                saveIndex: StreamIndex = stream.GetIndex[];
                stream.SetIndex[MimData.fixupLoc];
                WriteObjectUnits[@MimData.codeSeg, MobDefs.SGRecord.SIZE];
                WriteObjectUnits[@MimData.symSeg, MobDefs.SGRecord.SIZE];
                WriteObjectUnits[MimData.mtRoot, MimData.mtRootSize];
                stream.SetIndex[saveIndex];
                };
            IF padding.base # NIL THEN zone.FREE[@padding.base];
            stream Ź NIL;
            };

    }.
    <<>>