<<>>
    <<MobOpsImpl.mesa>>
        <<Copyright Ó 1988, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Andy Litman August 24, 1988 8:52:52 pm PDT>>
        <<JKF January 11, 1989 9:18:59 pm PST>>
        <<Peter B. Kessler October 18, 1988 4:57:32 pm PDT>>
        <<Russ Atkinson (RRA) December 19, 1988 5:02:37 pm PST>>
            <<>>
        DIRECTORY
            IO USING [GetLength, SetIndex, STREAM, UnsafeGetBlock],
            MobDefs USING [Base, FTSelf, MobBase, MTIndex, SGHandle, SGNull, VersionStamp],
            MobMapper USING [AlterMob],
            MobOps USING [],
            Rope USING [ROPE],
            Symbols USING [Base, MDFirst],
            SymbolSegment USING [Base, biases, bodyType, ctxType, ExtFirst, extType, FGHeader, htType, ltType, mdType, seType, ssType, 
            STHeader, stType, treeType, VersionID],
            SymbolTable USING [],
            SymbolTablePrivate USING [SymbolTableBaseRep],
            VM USING [AddressForPageNumber, Free, Interval, nullInterval, PagesForBytes, SimpleAllocate];

    MobOpsImpl: PROGRAM
        IMPORTS IO, MobMapper, VM
        EXPORTS MobOps, SymbolTable
        ~ {

        <<Cookies avoid having any global state>>
        Cookie: TYPE = REF CookieObj;
        CookieObj: PUBLIC TYPE = RECORD [
            mob: MobDefs.MobBase,
            openFile: IO.STREAM
            ];

        bytesPerUnit: NAT = BYTES[UNIT];

        FileError: PUBLIC ERROR[err: Rope.ROPE] = CODE;
        WrongMobdefsVersion: PUBLIC ERROR = CODE;
        Configuration: PUBLIC ERROR = CODE;
        NoSymbols: PUBLIC ERROR = CODE;
        WrongSymbolsVersion: PUBLIC ERROR = CODE;

        DoMobStream: PUBLIC PROC
        [file: IO.STREAM, proc: PROC[mob: MobDefs.MobBase, cookie: Cookie]] = {
            mob: MobDefs.MobBase;
            interval: VM.Interval Ź VM.nullInterval;
            openFile: IO.STREAM;
            allocedBytes: INT Ź IO.GetLength[file];
            err: Rope.ROPE Ź NIL;
            Cleanup: PROC[] = {VM.Free[interval]};
            openFile Ź file;
            IF err # NIL THEN ERROR FileError[err];
            interval Ź VM.SimpleAllocate[VM.PagesForBytes[allocedBytes]];
            mob Ź VM.AddressForPageNumber[interval.page];
            IO.SetIndex[openFile, 0];
            [] Ź IO.UnsafeGetBlock[openFile, [LOOPHOLE[mob], 0, allocedBytes]];
            IF MobMapper.AlterMob[mob, LOOPHOLE[mob], allocedBytes/BYTES[UNIT]] = badVersion THEN {
                Cleanup[];
                ERROR WrongMobdefsVersion;
                };
            proc[mob, NEW[CookieObj Ź [mob, openFile]]
                ! UNWIND => Cleanup[];
                ];
            Cleanup[];
            };

        STB: TYPE = REF SymbolTableBaseRep;
        SymbolTableBaseRep: PUBLIC TYPE = SymbolTablePrivate.SymbolTableBaseRep;

        DoSymbols: PUBLIC PROC [cookie: Cookie, proc: PROC[sym: STB]] = {
            sym: STB Ź NIL;
            sgb: MobDefs.Base = LOOPHOLE[cookie.mob+cookie.mob.sgOffset.units];
            mtb: MobDefs.Base = LOOPHOLE[cookie.mob+cookie.mob.mtOffset.units];
            sgh: MobDefs.SGHandle = IF mtb[FIRST[MobDefs.MTIndex]].sseg = MobDefs.SGNull
            THEN ERROR NoSymbols
            ELSE @sgb[mtb[FIRST[MobDefs.MTIndex]].sseg];
            stb: LONG POINTER TO SymbolSegment.STHeader = LOOPHOLE[cookie.mob+sgh.base.units];
            IF cookie.mob.nConfigs # 0 THEN ERROR Configuration;
            IF sgh.file # MobDefs.FTSelf OR sgh.units.units = 0 THEN ERROR NoSymbols;
            IF stb.versionIdent # SymbolSegment.VersionID THEN
                <<Consistency check failed!>>
                ERROR WrongSymbolsVersion;
            sym Ź InstallTable[stb];
            proc[sym];
            };

        InstallTable: PROC [node: LONG POINTER] RETURNS [STB] = {
            b: LONG POINTER = node;
            tB: SymbolSegment.Base = LOOPHOLE[b];
            p: LONG POINTER TO SymbolSegment.STHeader = b;
            base: STB Ź NEW[SymbolTableBaseRep];
            base.cacheInfo Ź LOOPHOLE[node];
            base.hashVec Ź b+p.hvBlock.offset;
            base.htb Ź tB + p.htBlock.offset - SymbolSegment.biases[SymbolSegment.htType];
            base.ssb Ź b + p.ssBlock.offset - SymbolSegment.biases[SymbolSegment.ssType];
            base.seb Ź tB + p.seBlock.offset - SymbolSegment.biases[SymbolSegment.seType];
            base.ctxb Ź tB + p.ctxBlock.offset - SymbolSegment.biases[SymbolSegment.ctxType];
            base.mdb Ź tB + p.mdBlock.offset - SymbolSegment.biases[SymbolSegment.mdType];
            base.bb Ź tB + p.bodyBlock.offset - SymbolSegment.biases[SymbolSegment.bodyType];
            base.tb Ź tB + p.treeBlock.offset - SymbolSegment.biases[SymbolSegment.treeType];
            base.ltb Ź tB + p.litBlock.offset - SymbolSegment.biases[SymbolSegment.ltType];
            base.stb Ź tB + p.sLitBlock.offset - SymbolSegment.biases[SymbolSegment.stType];
            base.extb Ź tB + p.extBlock.offset - SymbolSegment.biases[SymbolSegment.extType];
            base.mdLimit Ź Symbols.MDFirst + p.mdBlock.size;
            base.extLimit Ź SymbolSegment.ExtFirst + p.extBlock.size;
            base.mainCtx Ź p.outerCtx;  base.stHandle Ź p;
            IF p.fgRelBase = 0
                THEN {
                    base.sourceFile Ź NIL;
                    base.fgTable Ź NIL;
                    }
                ELSE {
                    bytesPerAU: NAT = BYTES[UNIT];
                    q: LONG POINTER TO SymbolSegment.FGHeader
                    = LOOPHOLE[b + p.fgRelBase/bytesPerAU];
                    source: LONG STRING = LOOPHOLE[q + SIZE[SymbolSegment.FGHeader[0]] - SIZE[StringBody[0]]];
                    base.sourceFile Ź source;
                    base.fgTable Ź DESCRIPTOR[q + q.offset, q.length];
                    };
            IF base.ssb.length = 0 OR base.ssb.length > base.ssb.maxlength THEN ERROR;
                <<Something is NOT kosher with the string table!>>
            RETURN [base];
            };

        Cache: TYPE ~ REF CacheList Ź NIL;
            CacheRep: PUBLIC TYPE = CacheList;
            CacheList: TYPE = REF CacheListRep;
            CacheListRep: TYPE ~ RECORD [
                rest: CacheList,
                version: MobDefs.VersionStamp,
                stb: STB,
                interval: VM.Interval];

        DoCachedSymbols: PUBLIC PROC [cookie: Cookie, proc: PROC[sym: STB], cache: Cache] = {
            interval: VM.Interval;
            sym: STB Ź NIL;
            sgb: MobDefs.Base = LOOPHOLE[cookie.mob+cookie.mob.sgOffset.units];
            mtb: MobDefs.Base = LOOPHOLE[cookie.mob+cookie.mob.mtOffset.units];
            sgh: MobDefs.SGHandle Ź IF mtb[FIRST[MobDefs.MTIndex]].sseg = MobDefs.SGNull
            THEN ERROR NoSymbols
            ELSE @sgb[mtb[FIRST[MobDefs.MTIndex]].sseg];
            bytes: INT = (sgh.units.units+sgh.extraUnits.units)*BYTES[UNIT];
            stb: LONG POINTER TO SymbolSegment.STHeader Ź LOOPHOLE[cookie.mob+sgh.base.units];
            symbolSegment: LONG POINTER TO SymbolSegment.STHeader Ź NIL;

            IF cookie.mob.nConfigs # 0 THEN ERROR Configuration;
            IF sgh.file # MobDefs.FTSelf OR sgh.units.units = 0 THEN ERROR NoSymbols;
            IF stb.versionIdent # SymbolSegment.VersionID THEN ERROR WrongSymbolsVersion;
            IF cache = NIL THEN {
                <<No caching, so no copying>>
                sym Ź InstallTable[stb];
                proc[sym];
                RETURN;
                };
            FOR each: CacheList Ź cache­, each.rest WHILE each # NIL DO
                <<Search the cache for the desired version>>
                IF each.version = stb.version THEN {
                    <<Found it!>>
                    proc[each.stb];
                    RETURN;
                    };
                ENDLOOP;
            interval Ź VM.SimpleAllocate[VM.PagesForBytes[bytes]];
            symbolSegment Ź VM.AddressForPageNumber[interval.page];
            CopyWords[
            dst: LOOPHOLE[symbolSegment],
            src: LOOPHOLE[stb],
            nwords: bytes/BYTES[WORD]];
            sym Ź InstallTable[symbolSegment];
            cache­ Ź NEW[CacheListRep Ź [cache­, symbolSegment.version, sym, interval]];
            proc[sym];
            };

        NewCache: PUBLIC PROC RETURNS [Cache] ~ {
            cache: Cache ~ NEW[CacheList Ź NIL];
            RETURN [cache];
            };

        FlushCache: PUBLIC PROC [cache: Cache] ~ {
            IF cache # NIL THEN {
                list: CacheList = cache­;
                cache­ Ź NIL;
                FOR left: CacheList Ź list, left.rest UNTIL left = NIL DO
                    VM.Free[left.interval];
                    ENDLOOP;
                cache­ Ź NIL;
                };
            };

        CopyWords: PROC [dst, src: LONG POINTER TO WORD, nwords: CARD] = {
            <<Copy from the src into the dst (dumb, really)>>
            BlockPtr: TYPE = LONG POINTER TO Block;
            Block: TYPE = ARRAY [0..16) OF WORD;
            WHILE nwords >= WORDS[Block] DO
                LOOPHOLE[dst, BlockPtr]­ Ź LOOPHOLE[src, BlockPtr]­;
                src Ź src + SIZE[Block];
                dst Ź dst + SIZE[Block];
                nwords Ź nwords - WORDS[Block];
                ENDLOOP;
            WHILE nwords # 0 DO
                dst­ Ź src­;
                src Ź src + SIZE[WORD];
                dst Ź dst + SIZE[WORD];
                nwords Ź nwords - 1;
                ENDLOOP;
            };

    }.