<<>>
    <<MimSysOpsImpl.mesa>>
        <<Copyright Ó 1987, 1988, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) December 13, 1988 1:39:28 am PST>>
        <<JKF February 9, 1989 5:19:20 pm PST>>

        DIRECTORY
            BasicTime,
            FS,
            IO,
            MimSysOps,
            MimSysOpsPrivate,
            Rope,
            VM;

MimSysOpsImpl: CEDAR MONITOR
    IMPORTS FS, IO, Rope, VM
    EXPORTS MimSysOps
    = BEGIN OPEN MimSysOps, MimSysOpsPrivate;

    GMT: TYPE = BasicTime.GMT;
        nullGMT: GMT = BasicTime.nullGMT;
    ROPE: TYPE = Rope.ROPE;
    STREAM: TYPE = IO.STREAM;

    currentInterceptor: Interceptor Ź NIL;
    openList: OpenStreamList Ź NIL;

    OpenStreamList: TYPE = LIST OF OpenStreamEntry;
    OpenStreamEntry: TYPE = RECORD [stream: STREAM, kind: OpenKind];

    Intercept: PUBLIC ENTRY PROC [interceptor: Interceptor] RETURNS [old: Interceptor] = {
        old Ź currentInterceptor;
        currentInterceptor Ź interceptor;
        };
        <<>>
    Open: PUBLIC PROC [name: ROPE, kind: OpenKind]
    RETURNS [stream: STREAM Ź NIL, err: ROPE Ź NIL, time: GMT Ź nullGMT] = {
        interceptor: Interceptor Ź currentInterceptor;
        IF interceptor # NIL AND interceptor.open # NIL
            THEN
                [stream, err, time] Ź interceptor.open[interceptor, name, kind]
            ELSE {
                <<FS supplies the default operation>>
                ENABLE FS.Error => {err Ź error.explanation; GO TO oops};
                st: STREAM Ź FS.StreamOpen[
                fileName: name,
                accessOptions: IF kind = read THEN $read ELSE $create];
                time Ź FS.GetInfo[FS.OpenFileFromStream[st]].created;
                stream Ź st;
                };
        IF err = NIL THEN AddToList[stream, kind];
        EXITS oops => {};
        };
        <<>>
    Close: PUBLIC PROC [stream: STREAM, abortAndDelete: BOOL] RETURNS [err: ROPE] = {
        interceptor: Interceptor Ź currentInterceptor;
        kind: OpenKind;
        [stream, kind] Ź RemFromList[stream];
        IF stream = NIL THEN RETURN;
        IF interceptor # NIL AND interceptor.close # NIL
            THEN
                err Ź interceptor.close[interceptor, stream, abortAndDelete]
            ELSE {
                <<FS supplies the default operation>>
                ENABLE {
                    FS.Error => {err Ź error.explanation; GO TO exit};
                    IO.Error => GO TO exit;
                    };
                file: FS.OpenFile Ź FS.OpenFileFromStream[stream];
                name: ROPE Ź FS.GetName[file].fullFName;
                time: BasicTime.GMT Ź FS.GetInfo[file].created;
                SELECT kind FROM
                    read, writeLog => IO.Close[stream];
                    ENDCASE => {
                        IO.Close[stream, abortAndDelete];
                        IF abortAndDelete THEN FS.Delete[name, time];
                        };
                };
        EXITS exit => {};
        };

    Delete: PUBLIC PROC [name: ROPE] RETURNS [err: ROPE] = {
        interceptor: Interceptor Ź currentInterceptor;
        IF interceptor # NIL AND interceptor.delete # NIL
            THEN err Ź interceptor.delete[interceptor, name]
            ELSE FS.Delete[name ! FS.Error => {err Ź error.explanation; CONTINUE}];
        };

    Cleanup: PUBLIC PROC [abortAndDelete: BOOL] = {
        DO
            sample: LIST OF MappedFileInner Ź mappedFiles;
            IF sample = NIL THEN EXIT;
            [] Ź RemMappedFileInner[sample.first, FALSE];
            ENDLOOP;
        DO
            sample: OpenStreamList Ź openList;
            IF sample = NIL THEN EXIT;
            [] Ź Close[sample.first.stream, abortAndDelete];
            ENDLOOP;
        };

    RemFromList: ENTRY PROC [stream: STREAM]
    RETURNS [st: STREAM Ź NIL, kind: OpenKind Ź read] = {
        lag: OpenStreamList Ź openList;
        IF lag # NIL THEN {
            IF lag.first.stream = stream THEN {
                st Ź stream;
                kind Ź lag.first.kind;
                openList Ź lag.rest;
                RETURN;
                };
            DO
                next: OpenStreamList Ź lag.rest;
                IF next = NIL THEN EXIT;
                IF next.first.stream = stream THEN {
                    st Ź stream;
                    kind Ź next.first.kind;
                    lag.rest Ź next.rest;
                    RETURN;
                    }; 
                lag Ź next;
                ENDLOOP;
            };
        };
        <<>>
    AddToList: ENTRY PROC [stream: STREAM, kind: OpenKind] = {
        openList Ź CONS[ [stream, kind], openList];
        };
<<Mapped file support>>
    mappedFiles: LIST OF MappedFileInner Ź NIL;

    MappedFile: TYPE = REF MappedFileRecord;
    MappedFileRecord: PUBLIC TYPE = MimSysOpsPrivate.MappedFileRecord;

    FindMappedFile: ENTRY PROC [name: ROPE] RETURNS [mf: MappedFile] = {
        ENABLE UNWIND => NULL;
        FOR each: LIST OF MappedFileInner Ź mappedFiles, each.rest WHILE each # NIL DO
            mfi: MappedFileInner Ź each.first;
            IF Rope.Equal[name, mfi.name] THEN {
                mfi.count Ź mfi.count + 1;
                RETURN [NEW[MappedFileRecord Ź [mfi]]];
                };
            ENDLOOP;
        RETURN [NIL];
        };

    AddMappedFileInner: ENTRY PROC [mfi: MappedFileInner] = {
        mappedFiles Ź CONS[mfi, mappedFiles];
        };

    DestroyHandle: ENTRY PROC [mf: MappedFile] RETURNS [mfi: MappedFileInner] = {
        IF mf # NIL THEN {
            mfi Ź mf.mfi;
            mf.mfi Ź NIL;
            };
        };

    RemMappedFileInner: ENTRY PROC [mfi: MappedFileInner, decr: BOOL]
    RETURNS [st: STREAM] = {
        ENABLE UNWIND => NULL;
        lag: LIST OF MappedFileInner Ź mappedFiles;
        IF decr THEN {
            IF mfi.count > 0 THEN mfi.count Ź mfi.count - 1;
            RETURN;
            };
        IF lag # NIL THEN {
            interval: VM.Interval Ź mfi.interval;
            st Ź mfi.stream;
            mfi.stream Ź NIL;
            mfi.interval Ź VM.nullInterval;
            mfi.base Ź NIL;
            IF interval # VM.nullInterval THEN TRUSTED {VM.Free[interval]};
            IF lag.first = mfi THEN {mappedFiles Ź lag.rest; RETURN};
            FOR each: LIST OF MappedFileInner Ź lag.rest, each.rest WHILE each # NIL DO
                IF each.first = mfi THEN {lag.rest Ź each.rest; RETURN};
                lag Ź each;
                ENDLOOP;
            };
        };

    Map: PUBLIC PROC [name: ROPE] RETURNS [mf: MappedFile, err: ROPE] = {
        mf Ź FindMappedFile[name];
        IF mf = NIL THEN {
            stream: STREAM;
            time: BasicTime.GMT;
            [stream, err, time] Ź Open[name, read];
            IF stream # NIL THEN {
                bytes: INT Ź IO.GetLength[stream];
                interval: VM.Interval Ź VM.SimpleAllocate[VM.PagesForBytes[bytes]];
                mfi: MappedFileInner Ź NEW[MappedFileInnerRecord Ź [
                    name: name,
                    interval: interval,
                    count: 1,
                    stream: stream,
                    base: VM.AddressForPageNumber[interval.page],
                    bytes: bytes]];
                TRUSTED {
                    wp: LONG POINTER TO CARD Ź LOOPHOLE[mfi.base];
                    wn: CARD Ź VM.BytesForPages[interval.count] / BYTES[CARD];
                    WHILE wn # 0 DO
                        wp­ Ź CARD.LAST;
                        wn Ź wn - 1;
                        ENDLOOP;
                    IO.SetIndex[stream, 0];
                    [] Ź IO.UnsafeGetBlock[
                    self: stream,
                    block: [base: mfi.base, startIndex: 0, count: bytes]];
                    };
                [] Ź Close[stream, TRUE];  -- new
                mfi.stream Ź NIL; -- new
                AddMappedFileInner[mfi];
                mf Ź NEW[MappedFileRecord Ź [mfi]];
                };
            };
        };

    UnMap: PUBLIC PROC [mf: MappedFile] = {
        mfi: MappedFileInner Ź DestroyHandle[mf];
        IF mfi # NIL THEN {
            st: STREAM Ź RemMappedFileInner[mfi, TRUE];
            IF st # NIL THEN {
                [] Ź Close[st, TRUE];
                };
            };
        };

    MapBase: PUBLIC PROC [mf: MappedFile] RETURNS [LONG POINTER] = {
        RETURN [mf.base];
        };

    MapLength: PUBLIC PROC [mf: MappedFile] RETURNS [CARD] = {
        RETURN [mf.bytes];
        };

    END.