<<>>
    <<CinderSysOpsImpl.mesa>>
        <<Copyright Ó 1987, 1989, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) November 20, 1987 4:45:58 pm PST>>
        <<Andy Litman February 16, 1988 11:39:36 pm PST>>
        <<JKF July 22, 1989 3:58:35 pm PDT>>

    DIRECTORY
        BasicTime USING [GMT, nullGMT],
        CinderSysOps USING [Interceptor,  OpenKind], 
        FS USING [Delete, Error, GetInfo, GetName, OpenFile, OpenFileFromStream, StreamOpen],
        IO USING [Close, Error, STREAM],
        Rope USING [ROPE];
CinderSysOpsImpl: CEDAR MONITOR
    IMPORTS FS, IO
    EXPORTS CinderSysOps
    = BEGIN 

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

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

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

    Intercept: PUBLIC ENTRY PROC [interceptor: CinderSysOps.Interceptor] RETURNS [old: CinderSysOps.Interceptor] = {
        old Ź currentInterceptor;
        currentInterceptor Ź interceptor;
        };
        <<>>
    Open: PUBLIC PROC [name: ROPE, kind: CinderSysOps.OpenKind]
    RETURNS [stream: STREAM Ź NIL, err: ROPE Ź NIL, time: GMT Ź nullGMT] = {
        interceptor: CinderSysOps.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: CinderSysOps.Interceptor Ź currentInterceptor;
        kind: CinderSysOps.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: CinderSysOps.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: OpenStreamList Ź openList;
            IF sample = NIL THEN EXIT;
            [] Ź Close[sample.first.stream, abortAndDelete];
            ENDLOOP;
        };

    RemFromList: ENTRY PROC [stream: STREAM]
    RETURNS [st: STREAM Ź NIL, kind: CinderSysOps.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: CinderSysOps.OpenKind] = {
        openList Ź CONS[ [stream, kind], openList];
        };
        <<>>
    END.