
    <<XlImplMainLoop.mesa>>
        <<Copyright Ó 1988, 1989, 1990, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi, April 7, 1988 6:13:15 pm PST>>
        <<Christian Jacobi, October 19, 1993 3:39 pm PDT>>
        <<>>
    DIRECTORY 
        Atom, Basics, ForkOps, IO, Process, Rope, RuntimeError, SafeStorage, Xl, XlDispatch, XlEndianPrivate, XlExtensions, 
        XlKeyButPrivate, XlPrivate, XlPrivateErrorHandling, XlPrivateSplit, XlPrivateTypes, XlRecycleMotionEvents, XlService, 
        XlSpeedHacks, XlPrivateDebug;

    XlImplMainLoop: CEDAR MONITOR LOCKS c USING c: Connection
        IMPORTS Atom, Basics, ForkOps, IO, Process, RuntimeError, SafeStorage, Xl, XlDispatch, XlExtensions, XlKeyButPrivate, XlPrivate, 
        XlPrivateErrorHandling, XlRecycleMotionEvents, XlService
        EXPORTS Xl, XlSpeedHacks, XlPrivate, XlPrivateSplit, XlPrivateDebug
        SHARES XlDispatch, XlPrivateTypes =
    BEGIN OPEN Xl, XlPrivate;

    ConnectionPrivateImplRec: TYPE = XlPrivateTypes.ConnectionPrivateImplRec;
    <<Xl.>>ConnectionPrivate: PUBLIC TYPE = XlPrivateTypes.ConnectionPrivateImplRec;

    ReplyGotProc: TYPE = XlPrivate.ReplyGotProc;

    weAreDebugging: BOOL ~ TRUE; --manifest constant for evential compile time code omissions!
    maxReplyLeng: CARD32 = LAST[INT16];
    replyTimeout: Process.Ticks Ź Process.MsecToTicks[10000];
    untracedZone: ZONE; 

    RRead16: PROC [r: Reply] RETURNS [CARD16] = {
        RETURN [Read16[r]];
        };

    RRead32: PROC [r: Reply] RETURNS [CARD32] = {
        RETURN [Read32[r]]
        };

    IReadTime: PROC [c: Connection, r: Reply] RETURNS [t: TimeStamp] = INLINE {
        t Ź [Read32[r]];
        c.lastTimeStamp Ź t;
        };

    ReadWindow: PROC [r: Reply] RETURNS [Window] ~ {
        RETURN [ToWindow[NIL, Read32[r]]]
        };

    InlineReadWindow: PROC [r: Reply] RETURNS [Window] ~ INLINE {
        RETURN [ToWindow[NIL, Read32[r]]]
        };

    InlineReadINT16: PROC [r: Reply] RETURNS [INT16] = INLINE {
        RETURN [LOOPHOLE[Read16[r], INT16]]
        };

    ReadINT16: PROC [r: Reply] RETURNS [INT16] ~ {
        RETURN [LOOPHOLE[Read16[r], INT16]]
        };

    ReadGeometry: PROC [r: Reply] RETURNS [g: Geometry] ~ {
        g.pos.x Ź ReadINT16[r];
        g.pos.y Ź ReadINT16[r];
        g.size.width Ź RRead16[r];
        g.size.height Ź RRead16[r];
        g.borderWidth Ź RRead16[r];
        };

    CheckReplyPos: PROC [r: Reply, i: INTŹ0] ~ INLINE {
        IF r.next+i#32 THEN ERROR;
        };

    FreeExts: PROC [replyStuff: REF ImplReplyStuffRep] = {
        IF replyStuff#NIL THEN {
            replyStuff.freeVarPart1 Ź NIL;
            replyStuff.freeVarPart2 Ź NIL;
            replyStuff.freeVarPart3 Ź NIL;
            replyStuff.freeReply1 Ź NIL;
            replyStuff.freeReply2 Ź NIL;
            replyStuff.freeReply3 Ź NIL;
            };
        };


    NewExt: PROC [replyStuff: REF ImplReplyStuffRep, reply: Reply, sz: CARD32] = TRUSTED {
        <<--Called only inside Connection Reader process>>
        <<--Order important since not monitored for speed reasons>>
        t: REF Basics.RawBytes;
        leng: CARD;
        t Ź replyStuff.freeVarPart1; 
        IF t#NIL THEN {
            IF (leng Ź LOOPHOLE[t, REF CARD]­) >= sz THEN {
                replyStuff.freeVarPart1 Ź NIL;
                reply.varLength Ź leng;
                reply.varPart Ź t;
                RETURN
                };
            };
        t Ź replyStuff.freeVarPart2; 
        IF t#NIL THEN {
            IF (leng Ź LOOPHOLE[t, REF CARD]­) >= sz THEN {
                replyStuff.freeVarPart2 Ź NIL;
                reply.varLength Ź leng;
                reply.varPart Ź t;
                RETURN
                };
            };
        t Ź replyStuff.freeVarPart3; 
        IF t#NIL THEN {
            IF (leng Ź LOOPHOLE[t, REF CARD]­) >= sz THEN {
                replyStuff.freeVarPart3 Ź NIL;
                reply.varLength Ź leng;
                reply.varPart Ź t;
                RETURN
                };
            };
        leng Ź sz+8; -- increase size for higher probability of reuse
        reply.varPart Ź untracedZone.NEW[Basics.RawBytes[leng]]; 
        reply.varLength Ź leng; 
        };

    DisposeReply: PUBLIC PROC [c: Connection, r: Reply] = {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        IF r#NIL THEN {
            vp: REF Basics.RawBytes Ź r.varPart;
            IF vp#NIL AND r.varLength>3 THEN {
                FreeVarpart: PROC [rp: REF ImplReplyStuffRep, vp: REF Basics.RawBytes, bytes: CARD] = TRUSTED {
                    t: REF Basics.RawBytes;
                    t Ź rp.freeVarPart3;
                    IF t#NIL AND LOOPHOLE[t, POINTER TO CARD]­ < bytes THEN {
                        rp.freeVarPart3 Ź vp; RETURN
                        };
                    t Ź rp.freeVarPart2;
                    IF t#NIL AND LOOPHOLE[t, POINTER TO CARD]­ < bytes THEN {
                        rp.freeVarPart2 Ź vp; RETURN
                        };
                    rp.freeVarPart1 Ź vp; --give cache a chance to shrink in size
                    };
                TRUSTED {
                    LOOPHOLE[vp, POINTER TO CARD]­ Ź r.varLength
                    };
                SELECT TRUE FROM
                    rp.freeVarPart1=NIL => rp.freeVarPart1 Ź vp;
                    rp.freeVarPart2=NIL => rp.freeVarPart2 Ź vp;
                    rp.freeVarPart3=NIL => rp.freeVarPart3 Ź vp;
                    ENDCASE => FreeVarpart[rp, vp, r.varLength];
                };
            r.varPart Ź NIL; r.varLength Ź 0;
            SELECT TRUE FROM
                rp.freeReply1=NIL => rp.freeReply1 Ź r;
                rp.freeReply2=NIL => rp.freeReply2 Ź r;
                rp.freeReply3=NIL => rp.freeReply3 Ź r;
                ENDCASE => {};
            };
        };

    SafeNewReply: PROC [] RETURNS [r: Reply] = {
        r Ź NEW[ReplyRec]; 
        };

    NewReply: PROC [rp: REF ImplReplyStuffRep] RETURNS [r: Reply] = INLINE {
        <<--Not monitored because>>
        <<--called only inside Connection Reader process>>
        r Ź rp.freeReply1;
        IF r#NIL THEN {rp.freeReply1 Ź NIL; RETURN};
        r Ź rp.freeReply2;
        IF r#NIL THEN {rp.freeReply2 Ź NIL; RETURN};
        r Ź rp.freeReply3;
        IF r#NIL THEN {rp.freeReply3 Ź NIL; RETURN};
        r Ź SafeNewReply[]; 
        };

    DispatchDead: PROC [c: Connection] = {
        dispatchHandle: XlDispatch.DispatchHandle Ź XlDispatch.GetDispatchHandle[c];
        ev: REF EventRep.local ~ NEW[EventRep.local];
        ev.connection Ź c;
        ev.who Ź $XlImpl;
        ev.key Ź $ConnectionDead;
        ev.data Ź $ConnectionDead;
        XlDispatch.Dispatch[dispatchHandle, ev];
        };

    MarkDead: PROC [c: Connection] = {
        IF c#NIL THEN {
            cPriv: REF ConnectionPrivateImplRec Ź c.cPriv;
            FreeExts[c.replyStuff];
            c.alive Ź FALSE;
            IF c.bufProblem=NIL THEN c.bufProblem Ź $dead;
            IF cPriv#NIL THEN {
                x: REF Connection Ź cPriv.refRefSelf;
                IF x#NIL THEN x­ Ź NIL;
                };
            TRUSTED {Process.Detach[FORK DispatchDead[c]]}; --forked so wedge wouldn't matter
            };
        };

    HandleKeyPress: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.keyPress Ź NEW[EventRep.keyPress]] = {
        e.keyCode Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.sameScreen Ź Read8[reply]#0 ;
        CheckReplyPos[reply, 1];
        };

    HandleKeyRelease: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.keyRelease Ź NEW[EventRep.keyRelease]] = {
        e.keyCode Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.sameScreen Ź Read8[reply]#0 ;
        CheckReplyPos[reply, 1];
        };

    HandleButtonPress: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.buttonPress Ź NEW[EventRep.buttonPress]] = {
        e.button Ź Read8[reply];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.sameScreen Ź Read8[reply]#0 ;
        CheckReplyPos[reply, 1];
        };

    HandleButtonRelease: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.buttonRelease Ź NEW[EventRep.buttonRelease]] = {
        e.button Ź Read8[reply];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.sameScreen Ź Read8[reply]#0 ;
        CheckReplyPos[reply, 1];
        };

    HandleEnterNotify: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.enterNotify Ź NEW[EventRep.enterNotify]] = {
        x: BYTE;
        e.detail Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.eventP.x Ź ReadINT16[reply];
        e.eventP.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.mode Ź VAL[Read8[reply]];
        x Ź Read8[reply];
        e.sameScreen Ź (x/2) MOD 2 # 0;
        e.focus Ź x MOD 2 # 0;
        CheckReplyPos[reply, 0];
        };

    HandleLeaveNotify: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.leaveNotify Ź NEW[EventRep.leaveNotify]] = {
        x: BYTE;
        e.detail Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.root Ź ReadWindow[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.child Ź ReadWindow[reply];
        e.rootP.x Ź ReadINT16[reply];
        e.rootP.y Ź ReadINT16[reply];
        e.eventP.x Ź ReadINT16[reply];
        e.eventP.y Ź ReadINT16[reply];
        e.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
        e.mode Ź VAL[Read8[reply]];
        x Ź Read8[reply];
        e.sameScreen Ź (x/2) MOD 2 # 0;
        e.focus Ź x MOD 2 # 0;
        CheckReplyPos[reply, 0];
        };

    HandleFocusIn: PROC [reply: Reply] RETURNS [e: REF EventRep.focusIn] = {
        e Ź NEW[EventRep.focusIn];
        e.detail Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.mode Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 23];
        };

    HandleFocusOut: PROC [reply: Reply] RETURNS [e: REF EventRep.focusOut Ź NEW[EventRep.focusOut]] = {
        e.detail Ź VAL[Read8[reply]];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.mode Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 23];
        };

    HandleKeymapNotify: PROC [reply: Reply, lastEvent: Event] RETURNS [e: REF EventRep.keymapNotify Ź NEW[EventRep.keymapNotify]] = {
        e.dispatchDrawable Ź nullDrawable;
        FOR i: INT IN [1..31] DO e.keys[i] Ź Read8[reply] ENDLOOP;
        e.previousEvent Ź lastEvent;
        CheckReplyPos[reply, 0];
        };

    HandleExpose: PROC [reply: Reply] RETURNS [e: REF EventRep.expose Ź NEW[EventRep.expose]] = {
        [] Ź Read8[reply];
        e.seq Ź RRead16[reply];
        e.window Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.window.drawable;
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.size.width Ź RRead16[reply];
        e.size.height Ź RRead16[reply];
        e.count Ź RRead16[reply];
        CheckReplyPos[reply, 14];
        };

    HandleGraphicsExposure: PROC [reply: Reply] RETURNS [e: REF EventRep.graphicsExposure Ź NEW[EventRep.graphicsExposure]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.drawable Ź e.dispatchDrawable Ź [RRead32[reply]];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.size.width Ź RRead16[reply];
        e.size.height Ź RRead16[reply];
        e.minorOpcode Ź RRead16[reply];
        e.count Ź RRead16[reply];
        e.majorOpcode Ź Read8[reply];
        CheckReplyPos[reply, 11];
        };

    HandleNoExposure: PROC [reply: Reply] RETURNS [e: REF EventRep.noExposure Ź NEW[EventRep.noExposure]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.drawable Ź e.dispatchDrawable Ź [RRead32[reply]];
        e.minorOpcode Ź RRead16[reply];
        e.majorOpcode Ź Read8[reply];
        CheckReplyPos[reply, 21];
        };

    HandleVisibilityNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.visibilityNotify Ź NEW[EventRep.visibilityNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.window Ź ReadWindow[reply];
        e.dispatchDrawable Ź e.window.drawable;
        e.state Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 23];
        };

    HandleCreateNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.createNotify Ź NEW[EventRep.createNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.parent Ź ReadWindow[reply]; 
        e.dispatchDrawable Ź e.parent.drawable;
        e.window Ź ReadWindow[reply];
        e.geometry Ź ReadGeometry[reply];
        e.overrideRedirect Ź Read8[reply]#0;
        CheckReplyPos[reply, 9];
        };

    HandleDestroyNotify: PROC [reply: Reply] RETURNS [dne: REF EventRep.destroyNotify Ź NEW[EventRep.destroyNotify]] = {
        Skip[reply, 1];
        dne.seq Ź RRead16[reply];
        dne.eventWindow Ź ReadWindow[reply];
            dne.dispatchDrawable Ź dne.eventWindow.drawable;
        dne.window Ź ReadWindow[reply];
        CheckReplyPos[reply, 20];
        };

    HandleUnmapNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.unmapNotify Ź NEW[EventRep.unmapNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
        e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        e.fromConfigure Ź Read8[reply]#0;
        CheckReplyPos[reply, 19];
        };

    HandleMapNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.mapNotify Ź NEW[EventRep.mapNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
        e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        e.overrideRedirect Ź Read8[reply]#0;
        CheckReplyPos[reply, 19];
        };

    HandleMapRequest: PROC [reply: Reply] RETURNS [e: REF EventRep.mapRequest Ź NEW[EventRep.mapRequest]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.parent Ź ReadWindow[reply];
        e.dispatchDrawable Ź e.parent.drawable;
        e.window Ź ReadWindow[reply];
        CheckReplyPos[reply, 20];
        };

    HandleReparentNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.reparentNotify Ź NEW[EventRep.reparentNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
        e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        e.parent Ź ReadWindow[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        e.overrideRedirect Ź Read8[reply]#0;
        CheckReplyPos[reply, 11];
        };

    HandleConfigureNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.configureNotify Ź NEW[EventRep.configureNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        e.aboveSibling Ź ReadWindow[reply];
        e.geometry Ź ReadGeometry[reply];
        e.overrideRedirect Ź Read8[reply];
        CheckReplyPos[reply, 5];
        };

    HandleConfigureRequest: PROC [reply: Reply] RETURNS [cre: REF EventRep.configureRequest Ź NEW[EventRep.configureRequest]] = {
        cre.stackMode Ź VAL[Read8[reply]];
        cre.seq Ź RRead16[reply];
        cre.parent Ź ReadWindow[reply];
            cre.dispatchDrawable Ź cre.parent.drawable;
        cre.window Ź ReadWindow[reply];
        cre.sibling Ź ReadWindow[reply];
        cre.geometry Ź ReadGeometry[reply];
        cre.valueMask Ź RRead16[reply];
        CheckReplyPos[reply, 4];
        };

    HandleGravityNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.gravityNotify Ź NEW[EventRep.gravityNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        e.pos.x Ź ReadINT16[reply];
        e.pos.y Ź ReadINT16[reply];
        CheckReplyPos[reply, 16];
        };

    HandleResizeRequest: PROC [reply: Reply] RETURNS [rre: REF EventRep.resizeRequest Ź NEW[EventRep.resizeRequest]] = {
        Skip[reply, 1];
        rre.seq Ź RRead16[reply];
        rre.window Ź ReadWindow[reply];
            rre.dispatchDrawable Ź rre.window.drawable;
        rre.size.width Ź RRead16[reply];
        rre.size.height Ź RRead16[reply];
        CheckReplyPos[reply, 20];
        };

    HandleCirculateNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.circulateNotify Ź NEW[EventRep.circulateNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.eventWindow Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.eventWindow.drawable;
        e.window Ź ReadWindow[reply];
        [] Ź ReadWindow[reply];
        e.place Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 15];
        };

    HandleCirculateRequest: PROC [reply: Reply] RETURNS [cre: REF EventRep.circulateRequest Ź NEW[EventRep.circulateRequest]] = {
        Skip[reply, 1];
        cre.seq Ź RRead16[reply];
        cre.parent Ź ReadWindow[reply];
            cre.dispatchDrawable Ź cre.parent.drawable;
        cre.window Ź ReadWindow[reply];
        [] Ź RRead32[reply];
        cre.place Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 15];
        };

    HandlePropertyNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.propertyNotify Ź NEW[EventRep.propertyNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.window Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.window.drawable;
        e.atom.a Ź RRead32[reply];
        e.timeStamp.t Ź RRead32[reply];
        e.state Ź VAL[Read8[reply]];
        CheckReplyPos[reply, 15];
        };

    HandleSelectionClear: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.selectionClear Ź NEW[EventRep.selectionClear]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.owner Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.owner.drawable;
        e.selection.a Ź RRead32[reply];
        CheckReplyPos[reply, 16];
        };

    HandleSelectionRequest: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.selectionRequest Ź 
    NEW[EventRep.selectionRequest]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.owner Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.owner.drawable;
        e.requestor Ź ReadWindow[reply];
        e.selection.a Ź RRead32[reply];
        e.target.a Ź RRead32[reply];
        e.property.a Ź RRead32[reply];
        CheckReplyPos[reply, 4];
        };

    HandleSelectionNotify: PROC [c: Connection, reply: Reply] RETURNS [e: REF EventRep.selectionNotify Ź NEW[EventRep.selectionNotify]] 
    = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.timeStamp Ź IReadTime[c, reply];
        e.requestor Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.requestor.drawable;
        e.selection.a Ź RRead32[reply];
        e.target.a Ź RRead32[reply];
        e.property.a Ź RRead32[reply];
        CheckReplyPos[reply, 8];
        };

    HandleColormapNotify: PROC [reply: Reply] RETURNS [e: REF EventRep.colorMapNotify Ź NEW[EventRep.colorMapNotify]] = {
        Skip[reply, 1];
        e.seq Ź RRead16[reply];
        e.window Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.window.drawable;
        e.colorMap Ź [RRead32[reply]];
        e.new Ź Read8[reply]#0;
        e.installed Ź Read8[reply]=1;
        CheckReplyPos[reply, 18];
        };

    HandleClientMessage: PROC [reply: Reply] RETURNS [e: REF EventRep.clientMessage Ź NEW[EventRep.clientMessage.b]] = {
        e.format Ź Read8[reply];
        e.seq Ź RRead16[reply];
        e.window Ź ReadWindow[reply];
            e.dispatchDrawable Ź e.window.drawable;
        e.typeAtom.a Ź RRead32[reply];
        SELECT e.format FROM
            16 => FOR i: [0..10) IN [0..10) DO e.h[i] Ź RRead16[reply] ENDLOOP;
            32 => FOR i: [0..5) IN [0..5) DO e.w[i] Ź RRead32[reply] ENDLOOP;
            ENDCASE => FOR i: [0..20) IN [0..20) DO e.b[i] Ź Read8[reply] ENDLOOP;
        CheckReplyPos[reply, 0];
        };

    HandleMapping: PROC [c: Connection, reply: Reply] RETURNS [mne: REF EventRep.mappingNotify Ź NEW[EventRep.mappingNotify]] = {
        cp: REF ConnectionPrivateImplRec ~ c.cPriv;
        mne.dispatchDrawable Ź nullDrawable;
        Skip[reply, 1];
        mne.seq Ź RRead16[reply];
        mne.request Ź VAL[Read8[reply]];
        mne.firstKeycode Ź Read8[reply];
        mne.count Ź Read8[reply];
        CheckReplyPos[reply, 25];
        <<<<flush caches!>> >>
        SELECT mne.request FROM
            modifier => {
                XlService.PutServiceProp[c, $x11PrivateMMappings, NIL]; --order!
                cp.mMappings Ź NIL;
                };
            keyboard => {
                XlService.PutServiceProp[c, $x11PrivateKMappings, NIL]; --order!
                cp.kMappings Ź NIL;
                };
            pointer => {
                BEGIN -- because the keyboard mapping might include some buttons
                    XlService.PutServiceProp[c, $x11PrivateKMappings, NIL]; 
                    cp.kMappings Ź NIL;
                    END;
                XlService.PutServiceProp[c, $x11PrivatePMappings, NIL]; --order!
                cp.pMappings Ź NIL;
                };
            ENDCASE => {
                <<--This is an error; but It is not disabling further access to the connection>>
                };
            <<--caching on service might not prevent multiple get-mapping requests since one connection might issue the get-mapping request 
            before an other connection flushed the cache; however this is unusual, and would not lead to wrong data but only to an 
            efficiency loss.>>
        };

    PartialIOError: ERROR = CODE; --Raised when stream stops with only partial information on it

    ConnectionReader: PROC [data: REF] ~ {
        <<This is forked as a process to handle all the errors, replys, and events.  Since this is the only process that reads, it does so 
        without a monitor.  It calls ENTRY procs to dispense the gathered data.>>
        ENABLE {
            UNWIND => {MarkDead[NARROW[data]]};
            ABORTED => {MarkDead[NARROW[data]]};
            IO.EndOfStream => {
                c: Connection ~ NARROW[data]; 
                MarkDead[c];
                IF c.recv=stream OR c.recv=IO.noInputStream OR c.recv=NIL THEN GOTO exitQuietly;
                };
            IO.Error => {
                c: Connection ~ NARROW[data]; 
                MarkDead[c];
                IF c.recv=stream OR c.recv=IO.noInputStream OR c.recv=NIL THEN GOTO exitQuietly;
                };
            PartialIOError => {
                c: Connection ~ NARROW[data]; 
                MarkDead[c];
                GOTO exitQuietly;
                };
            RuntimeError.UNCAUGHT => {
                c: Connection Ź NARROW[data]; 
                c.alive Ź FALSE
                <<--Not caught; please debug this and then put in a specific catch phrase>>
                };
            }; 
        DetachReply: PROC [] RETURNS [r: Reply] = INLINE { 
            <<--Inline to get rid of intermediate level variables in ConnectionReader>>
            r Ź reply;
            reply Ź NewReply[c.replyStuff];
            };
        c: Connection Ź NARROW[data];
        dispatchHandle: XlDispatch.DispatchHandle Ź XlDispatch.GetDispatchHandle[c];
        event, lastEvent: REF EventRep Ź NIL;
        reply: Reply Ź SafeNewReply[];
        mEventCache: REF XlRecycleMotionEvents.EventCache Ź XlRecycleMotionEvents.GetCache[c, [[LAST[CARD]]]];
        readyExtEvent: REF EventRep.extension Ź NEW[EventRep.extension];
        DO 
            TRUSTED {
                cnt: INT = IO.UnsafeGetBlock[c.recv, [base: LOOPHOLE[@reply.fix], count: 32]];
                IF cnt#32 THEN {
                    c.alive Ź FALSE;
                    IF cnt=0 AND IO.EndOf[c.recv] 
                        THEN GOTO exitQuietly
                        ELSE ERROR PartialIOError;
                    };
                };
            SetPos[reply, 1];
            SELECT (Get8[reply, 0] MOD 128) FROM
                1 => {--Reply;  should be fast
                    detached: Reply ~ DetachReply[];
                    sequenceNumber: Xl.SequenceNo ~ Get16[detached, 2];
                    more: CARD32 ~ Get32[detached, 4];
                    IF more>0 THEN {
                        nBytesRead: CARD32; 
                        replyBytes: CARD32 ~ more*4;
                        NewExt[c.replyStuff, detached, replyBytes];
                        TRUSTED {
                            nBytesRead Ź IO.UnsafeGetBlock[self: c.recv, 
                                block: [base: LOOPHOLE[detached.varPart], startIndex: 0, count: replyBytes]
                                ];
                            };
                        IF nBytesRead#replyBytes THEN { --ByteCountWrong
                            c.alive Ź FALSE; 
                            ERROR PartialIOError;
                            }; 
                        };
                    QueueReply[c, sequenceNumber, detached];
                    LOOP
                    };
                ORD[EventCode[motionNotify]] => {--should be fast
                    HandleMotion: PROC [reply: Reply] RETURNS [mne: REF EventRep.motionNotify] = INLINE {
                        mne Ź mEventCache.m1; mEventCache.m1 Ź NIL;
                        IF mne=NIL THEN {   
                            mne Ź mEventCache.m2; mEventCache.m2 Ź NIL;
                            IF mne=NIL THEN mne Ź NEW[EventRep.motionNotify];
                            };
                        mne.detail Ź VAL[Read8[reply]];
                        mne.seq Ź Read16[reply];
                        mne.timeStamp Ź [Read32[reply]];
                        mne.root Ź InlineReadWindow[reply];
                        mne.eventWindow Ź InlineReadWindow[reply];
                            mne.dispatchDrawable Ź mne.eventWindow.drawable;
                        mne.child Ź InlineReadWindow[reply];
                        mne.rootP.x Ź InlineReadINT16[reply];
                        mne.rootP.y Ź InlineReadINT16[reply];
                        mne.pos.x Ź InlineReadINT16[reply];
                        mne.pos.y Ź InlineReadINT16[reply];
                        mne.state Ź XlKeyButPrivate.SetFromWire[Read16[reply]];
                        mne.sameScreen Ź Read8[reply]#0;
                        CheckReplyPos[reply, 1];
                        RETURN [mne]
                        };
                    event Ź HandleMotion[reply];
                    };
                ORD[EventCode[keyPress]] => event Ź HandleKeyPress[c, reply];
                ORD[EventCode[keyRelease]] => event Ź HandleKeyRelease[c, reply];
                ORD[EventCode[buttonPress]] => event Ź HandleButtonPress[c, reply];
                ORD[EventCode[buttonRelease]] => event Ź HandleButtonRelease[c, reply];
                ORD[EventCode[enterNotify]] => event Ź HandleEnterNotify[c, reply];
                ORD[EventCode[leaveNotify]] => event Ź HandleLeaveNotify[c, reply];
                ORD[EventCode[focusIn]] => event Ź HandleFocusIn[reply];
                ORD[EventCode[focusOut]] => event Ź HandleFocusOut[reply];
                ORD[EventCode[keymapNotify]] => event Ź HandleKeymapNotify[reply, lastEvent];
                ORD[EventCode[expose]] => event Ź HandleExpose[reply];
                ORD[EventCode[graphicsExposure]] => event Ź HandleGraphicsExposure[reply];
                ORD[EventCode[noExposure]] => event Ź HandleNoExposure[reply];
                ORD[EventCode[visibilityNotify]] => event Ź HandleVisibilityNotify[reply];
                ORD[EventCode[createNotify]] => event Ź HandleCreateNotify[reply];
                ORD[EventCode[destroyNotify]] => {
                    dne: REF EventRep.destroyNotify ~ HandleDestroyNotify[reply];
                    event Ź dne;
                    <<-->>
                    <<--Normal dispatch and then remove of data structures.  >>
                    <<--It would look more elegant if removal of data structures were registered like a normal dispatch, but we want to keep the 
                    dispatch lists short and prefer special code for efficiency reasons.>>
                    event.originalCodeByte Ź Get8[reply, 0]; 
                    event.connection Ź c;
                    XlDispatch.Dispatch[dispatchHandle, event];
                    IF dne.window=dne.eventWindow AND event.originalCodeByte=ORD[EventCode[destroyNotify]] THEN { --we are not interested in inferiors 
                    nor in clients sending this event
                        XlDispatch.RemoveWindow[c, dne.window]; --NOT eventWindow!
                        };
                    lastEvent Ź dne;
                    LOOP
                    };
                ORD[EventCode[unmapNotify]] => event Ź HandleUnmapNotify[reply];
                ORD[EventCode[mapNotify]] => event Ź HandleMapNotify[reply];
                ORD[EventCode[mapRequest]] => event Ź HandleMapRequest[reply];
                ORD[EventCode[reparentNotify]] => event Ź HandleReparentNotify[reply];
                ORD[EventCode[configureNotify]] => event Ź HandleConfigureNotify[reply];
                ORD[EventCode[configureRequest]] => event Ź HandleConfigureRequest[reply];
                ORD[EventCode[gravityNotify]] => event Ź HandleGravityNotify[reply];
                ORD[EventCode[resizeRequest]] => event Ź HandleResizeRequest[reply];
                ORD[EventCode[circulateNotify]] => event Ź HandleCirculateNotify[reply];
                ORD[EventCode[circulateRequest]] => event Ź HandleCirculateRequest[reply];
                ORD[EventCode[propertyNotify]] => event Ź HandlePropertyNotify[reply];
                ORD[EventCode[selectionClear]] => event Ź HandleSelectionClear[c, reply];
                ORD[EventCode[selectionRequest]] => event Ź HandleSelectionRequest[c, reply];
                ORD[EventCode[selectionNotify]] => event Ź HandleSelectionNotify[c, reply];
                ORD[EventCode[colorMapNotify]] => event Ź HandleColormapNotify[reply];
                ORD[EventCode[clientMessage]] => event Ź HandleClientMessage[reply];
                ORD[EventCode[mappingNotify]] => event Ź HandleMapping[c, reply];
                0 => {--error
                    detached: Reply ~ DetachReply[];
                    sequenceNumber: Xl.SequenceNo Ź Get16[detached, 2];
                    QueueReply[c, sequenceNumber, detached];
                    LOOP
                    };
                ENDCASE => {
                    readyExtEvent.dispatchDrawable Ź nullDrawable;
                    readyExtEvent.bytes Ź reply.fix;
                    readyExtEvent.originalCodeByte Ź Get8[reply, 0]; 
                    readyExtEvent.connection Ź c;
                    lastEvent Ź readyExtEvent;
                    IF ~XlExtensions.ProcessExtensionEvent[readyExtEvent].reuse THEN {
                        readyExtEvent Ź NEW[EventRep.extension];
                        };
                    LOOP;
                    };
            event.originalCodeByte Ź Get8[reply, 0]; 
            event.connection Ź c;
            lastEvent Ź event;
            XlDispatch.Dispatch[dispatchHandle, event];
            ENDLOOP;
        EXITS
            exitQuietly => {};
        };

    QueueError: INTERNAL PROC [c: Connection, sequenceNumber: Xl.SequenceNo, replyText: Reply] ~ {
        err: REF EventRep.errorNotify Ź XlPrivateErrorHandling.NewErrorEvent[replyText, c, sequenceNumber];
        Enqueue[c.errorMatch.tq, c.errorMatch.proc, c.errorMatch.data, err];
        };

    KillReplies: PUBLIC PROC [c: Connection, wedged: BOOL Ź TRUE] = TRUSTED {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        IF rp#NIL THEN {
            p: Acceptor Ź rp.dequeuePoint;
            rp.enqueuePoint Ź NIL; --not monitored, but this procedure is idempotent
            rp.dequeuePoint Ź NIL;
            WHILE p#NIL DO
                next: Acceptor Ź p.next; 
                p.replyText Ź NewFakeErrorReply[p.sequenceNo, (IF wedged THEN connectionWedged ELSE requestFromDeadConnection)];
                p.mayContinue Ź TRUE;
                p Ź next;
                ENDLOOP
            };
        <<--Its not necessary to notify: replyReceived will time out.>>
        <<--This makes KillReplies callable external and internal>>
        };

    NewReplyStuff: PROC [] RETURNS [rp: REF ImplReplyStuffRep] = TRUSTED {
        rp Ź NEW[ImplReplyStuffRep];
        Process.InitializeCondition[@rp.gotGeneralReply, replyTimeout];
        };

<<<<>>
<<--good if modular arithmetic on SequenceNo works>>
<<--e.g. bitnumber of container allows it and SequenceNo fills container>>
<<InOrderStrictly: PROC [s1, s2: SequenceNo] RETURNS [BOOL] = INLINE {>>
<<--returns s1 happened strictly before s2>>
<<--INT32 for modulo 2**32 arithmetic>>
<<RETURN [(LOOPHOLE[s2, INT32]-LOOPHOLE[s1, INT32]) > 0]>>
<<};>>
<<InOrderOrSame: PROC [s1, s2: SequenceNo] RETURNS [BOOL] = INLINE {>>
<<--returns s1 happened before s2 or at the same time but not later>>
<<--INT32 for modulo 2**32 arithmetic>>
<<RETURN [(LOOPHOLE[s2, INT32]-LOOPHOLE[s1, INT32]) >= 0]>>
<<};>>
<<>>>>

<<--good if modular arithmetic on SequenceNo does not work>>
<<--e.g. If machine has no modular arithmetic>>
<<--e.g. SequenceNo does not fill container>>

    sequenceHalf: Xl.SequenceNo = LAST[CARD16]/2; --half of used range; independent on container
    InOrderStrictly: PROC [s1, s2: SequenceNo] RETURNS [BOOL] = INLINE {
    <<--returns s1 happened strictly before s2>>
        IF s2>s1 
            THEN RETURN [(s2-s1) < sequenceHalf]
            ELSE RETURN [(s1-s2) > sequenceHalf]
        };
    InOrderOrSame: PROC [s1, s2: SequenceNo] RETURNS [BOOL] = INLINE {
    <<--returns s1 happened before s2 or at the same time but not later>>
        IF s2>=s1 
            THEN RETURN [(s2-s1) < sequenceHalf]
            ELSE RETURN [(s1-s2) > sequenceHalf]
        };

    ArrivalExpected: PROC [c: Connection, s: SequenceNo] RETURNS [BOOL] = INLINE {
        <<--Returns "waiting for arrival of reply makes sense">>
        <<--under the assumption that the request s really sends a reply>>
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        IF InOrderStrictly[rp.lastAnswerdSeq, s] THEN {
            <<--it isn't here yet! >>
            <<--find out whether request is already initiated... >>
            <<--[note: c.sequenceNumber is incremented before request is on the wire]>>
            RETURN [ InOrderOrSame[s, c.sequenceNumber] ]
            };
        <<--its already here, ==> its arrival won't happen again >>
        RETURN [FALSE]
        };

    ReportedSequenceNumber: PUBLIC PROC [c: Connection] RETURNS [SequenceNo] = {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        RETURN [rp.lastAnswerdSeq]
        };

    WaitInitiatedRange: PUBLIC PROC [c: Connection, s: SequenceNo, flush: BOOL Ź TRUE] = {
    <<--If s reasonable and not too old then waits until reply is sent >>
    <<--If s is too old or not reasonable, returns immediately >>
    <<-->>
    <<--Use 3 little monitors instead a big one so we don't need to catch UNWIND >>
        Enter: ENTRY PROC [c: Connection, rp: REF ImplReplyStuffRep] = INLINE {
            rp.generalWaiters Ź rp.generalWaiters+1;
            };
        Leave: ENTRY PROC [c: Connection, rp: REF ImplReplyStuffRep] = INLINE {
            rp.generalWaiters Ź MAX[rp.generalWaiters-1, 0];
            };
        Wait: ENTRY PROC [c: Connection, rp: REF ImplReplyStuffRep] = {
            WAIT rp.gotGeneralReply; 
            };
        Flush: ENTRY PROC [c: Connection] = {
            XlPrivate.HardFlushBuffer[c];
            };
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        flushed: BOOL Ź FALSE; 
        IF rp=NIL THEN RETURN;
        Enter[c, rp];
        WHILE ArrivalExpected[c, s] AND c.alive AND c.bufProblem=NIL DO 
            IF flush THEN {Flush[c]; flush Ź FALSE};
            Wait[c, rp]; 
            ENDLOOP;
        Leave[c, rp];
        };

    InitiateRoundTrip: PUBLIC ENTRY PROC [c: Connection, flush: BOOL] RETURNS [seq: SequenceNo Ź 0] = {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        p: Acceptor Ź NewAcceptor[rp, ignoreAndFree];
        BInit[c, 43, 0, 1]; --GetInputFocus
        seq Ź c.sequenceNumber;
        ActivateAcceptor[rp, p, seq];
        FinishRequest[c];
        IF flush THEN XlPrivate.HardFlushBuffer[c];
        DontWaitForReplies[c, p];
        };

    ReplyStuffRep: PUBLIC TYPE = ImplReplyStuffRep;

    ImplReplyStuffRep: TYPE = RECORD [
        <<--Free lists>>
        freeReply1, freeReply2, freeReply3: Reply Ź NIL, --free'd unprotected
        freeVarPart1, freeVarPart2, freeVarPart3: REF Basics.RawBytes Ź NIL,  --free'd unprotected
        freeAcceptors: Acceptor,
        <<--Implementing pending requests>>
        enqueuePoint: Acceptor, --youngest element of queue for new requests
        dequeuePoint: Acceptor, --oldest element of queue not yet notified Acceptor
        <<--Implementing WaitInitiatedRange>>
        generalWaiters: INT Ź 0, --count of waiters without explicit Acceptor
        lastAnswerdSeq: SequenceNo Ź 0,
        gotGeneralReply: CONDITION 
        ];

    AcceptingCase: TYPE = {normalSingle, errorsAndOver, multiple, ignoreAndFree, specialDebugSingle};
        
    Acceptor: TYPE = REF AcceptorRec;
    AcceptorRec: TYPE = RECORD [
        next: PRIVATE Acceptor Ź NIL,
        sequenceNo: Xl.SequenceNo,
        case: AcceptingCase,
        inQueue, doneWaiting: BOOL Ź FALSE, --acceptor may be put on free list only if inQueue=FALSE and doneWaiting=TRUE 
        mayContinue: BOOL Ź FALSE,
        condition: CONDITION Ź [],
        errorMatch, overMatch: Xl.Match Ź NIL,
        replyText: Reply Ź NIL,--used for requests with single replys
        reportPartOfMultiple: ReplyGotProc Ź NIL, --used for requests with multiple replies
        data: REF Ź NIL --used for requests with multiple replies
        ];

    NewAcceptor: INTERNAL PROC [i: REF ImplReplyStuffRep, case: AcceptingCase] RETURNS [Acceptor] = { 
        <<--Get acceptor from free list or allocate one>>
        <<--Caller must either call WaitForReplies or DontWaitForReplies so we know when to free it again >>
        p: Acceptor Ź i.freeAcceptors;  
        IF p=NIL 
            THEN {
                p Ź NEW[AcceptorRec];
                <<--Just for the case when connection dies>>
                TRUSTED {Process.InitializeCondition[@p.condition, replyTimeout]};
                }
            ELSE {
                i.freeAcceptors Ź p.next; 
                p.next Ź NIL;
                p.doneWaiting Ź FALSE;
                p.mayContinue Ź FALSE;
                };
        p.case Ź case;
        RETURN [p];
        };

    FreeAcceptor: INTERNAL PROC [i: REF ImplReplyStuffRep, p: Acceptor]  = {
        <<--Put acceptor on free list>>
        p.next Ź i.freeAcceptors;
        i.freeAcceptors Ź p;
        p.replyText Ź NIL;
        p.data Ź NIL;
        p.overMatch Ź p.errorMatch Ź NIL;
        };

    ActivateAcceptor: INTERNAL PROC [i: REF ImplReplyStuffRep, p: Acceptor, seq: Xl.SequenceNo] = {
        <<--Enable acceptor to receive replies>>
        prev: Acceptor Ź i.enqueuePoint;
        IF weAreDebugging AND p.inQueue THEN ERROR;
        IF weAreDebugging AND p.next#NIL THEN ERROR;
        p.inQueue Ź TRUE;
        p.sequenceNo Ź seq;
    IF prev = NIL 
    THEN i.dequeuePoint Ź p 
    ELSE prev.next Ź p;
        i.enqueuePoint Ź p;
        };

    DeActivateAcceptor: INTERNAL PROC [i: REF ImplReplyStuffRep, p: Acceptor]  = {
    <<--No replies will be accepted anymore>>
    <<--Acceptor is freed if there is no waiter>>
        IF weAreDebugging AND ~p.inQueue THEN ERROR;
        IF weAreDebugging AND i.dequeuePoint#p THEN ERROR;
        p.inQueue Ź FALSE;
        IF (i.dequeuePoint Ź p.next)=NIL THEN i.enqueuePoint Ź NIL;
        IF p.doneWaiting THEN FreeAcceptor[i, p];
        };

    WaitForReplies: INTERNAL PROC [c: Xl.Connection, p: Acceptor] RETURNS [replyText: Reply] = <<INLINE>> {
        WHILE ~p.mayContinue AND c.alive DO 
            <<WARNING: This test is possible only because a periodical process requesting replies prevents p.sequenceNo to increase a whole 
            2**15 over the i.lastAnswerdSeq>>
            IF weAreDebugging THEN {
                i: REF ImplReplyStuffRep ~ c.replyStuff;
                IF InOrderOrSame[p.sequenceNo, i.lastAnswerdSeq] THEN ERROR
                };
            WAIT p.condition; 
            ENDLOOP;
        p.doneWaiting Ź TRUE;
        replyText Ź p.replyText;
        IF ~p.inQueue THEN FreeAcceptor[c.replyStuff, p];
        };

    DontWaitForReplies: INTERNAL PROC [c: Xl.Connection, p: Acceptor] = {
        <<--don't activate acceptor after calling DontWaitForReplies>>
        p.doneWaiting Ź TRUE;
        IF ~p.inQueue THEN FreeAcceptor[c.replyStuff, p];
        };

    NotifyReceiptOfReply: INTERNAL PROC [p: Acceptor] = INLINE {
        p.mayContinue Ź TRUE;
        NOTIFY p.condition; --only one waiter
        };

    FinishRequest: PROC [c: Connection] = INLINE {
        IF c.bufNext+c.bufSkipped#c.bufExpected THEN XlPrivate.BadImplError[c];
        c.bufReady Ź c.bufNext;
        c.needFlushing Ź TRUE;
        };

    NewFakeErrorReply: PROC [sequenceNumber: CARD, error: Xl.ErrorKind] RETURNS [reply: Reply] = {
        used: CARD16 Ź Basics.LowHalf[sequenceNumber];
        reply Ź SafeNewReply[];
        reply.fix[0] Ź 0;
        reply.fix[1] Ź ORD[error];
        reply.fix[2+XlEndianPrivate.highOff] Ź Basics.HighByte[used];
        reply.fix[2+XlEndianPrivate.lowOff] Ź Basics.LowByte[used];
        };
         
    FinishWithReply: PUBLIC INTERNAL PROC [c: Connection] RETURNS [replyText: Reply Ź NIL] = {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        p: Acceptor Ź NewAcceptor[rp, specialDebugSingle];
        ActivateAcceptor[rp, p, c.sequenceNumber];
        FinishRequest[c];
        XlPrivate.HardFlushBuffer[c];
        replyText Ź WaitForReplies[c, p];
        };

    DebugFinishWithReply: PUBLIC INTERNAL PROC [c: Connection] RETURNS [replyText: Reply Ź NIL] = {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        p: Acceptor Ź NewAcceptor[rp, normalSingle];
        ActivateAcceptor[rp, p, c.sequenceNumber];
        FinishRequest[c];
        XlPrivate.HardFlushBuffer[c];
        replyText Ź WaitForReplies[c, p];
        };

    debugArrayCnt: INT = 4000; --same as in XlImplUtilities
    DebugArray: TYPE = ARRAY [0..debugArrayCnt) OF BYTE Ź ALL[0];
    debugReplyNotExpected: SIGNAL ~ CODE;
    debugTheNotExpectedReply: Reply;
    debugTheNotExpectedFix: REF PACKED ARRAY [0..32) OF BYTE Ź NIL;
    debugSignalOnNotExpectedReply: BOOL Ź FALSE;
        DebugNotExpectedRepliesTRUE: PROC [] = {debugSignalOnNotExpectedReply Ź TRUE};
        DebugNotExpectedRepliesFALSE: PROC [] = {debugSignalOnNotExpectedReply Ź FALSE};
        <<In production we want to prevent to wedge the connection, even if something went wrong.>>
        <<For debugging we prefer to raise problems as early as possible.>>


    ExpectedReply: INTERNAL PROC [c: Connection, p: Acceptor, replyText: Reply] = <<INLINE>> {
        SELECT p.case FROM
            normalSingle => {
                p.replyText Ź replyText;
                NotifyReceiptOfReply[p];
                DeActivateAcceptor[c.replyStuff, p];
                };
            multiple => {
                more: BOOL;
                IF p.data=doneWithMultiple THEN {
                    <<--make an error, or, forget about it>>
                    RETURN
                    };
                more Ź p.reportPartOfMultiple[c, replyText, p.data];
                IF ~more THEN {p.data Ź doneWithMultiple; NotifyReceiptOfReply[p]};
                };
            errorsAndOver => {
                errorMatch: Xl.Match ~ p.errorMatch;
                IF errorMatch#NIL THEN {
                    tq: Xl.TQ Ź errorMatch.tq;
                    err: REF EventRep.errorNotify ~ NEW[EventRep.errorNotify];
                    err.seq Ź p.sequenceNo;
                    err.connection Ź c;
                    err.originalCodeByte Ź replyText.fix[0];
                    err.replyText Ź replyText;
                    IF tq=NIL THEN tq Ź Xl.CreateTQ[];
                    Xl.Enqueue[tq, errorMatch.proc, errorMatch.data, err];
                    p.overMatch Ź NIL;
                    };
                p.replyText Ź replyText;
                NotifyReceiptOfReply[p];
                };
            ignoreAndFree => {
                IF replyText.fix[0]=1 THEN DisposeReply[c, replyText];
                DeActivateAcceptor[c.replyStuff, p];
                NotifyReceiptOfReply[p];
                };
            specialDebugSingle => {
                IF p.data=$gotit THEN {
                    specialDebugCount Ź specialDebugCount+1;
                    Atom.PutProp[$XlDebug, $XlDebugSP, NEW[INT Ź specialDebugCount]];
                    };
                p.data Ź $gotit;
                p.replyText Ź replyText;
                NotifyReceiptOfReply[p];
                };
            ENDCASE => ERROR;
        };

    specialDebugCount: INT Ź 0;

    AbsenceOfReply: INTERNAL PROC [c: Connection, p: Acceptor] = <<INLINE>> {
        SELECT p.case FROM 
            ignoreAndFree => {
                <<--ok; maybe somebody waits (dependent on who set up) >>
                };
            errorsAndOver => {
                <<--this is expected>>
                <<--maybe somebody waits (dependent on who set up)>>
                IF p.overMatch#NIL THEN {
                    overMatch: Xl.Match ~ p.overMatch;
                    tq: Xl.TQ Ź overMatch.tq;
                    ev: REF Xl.EventRep.local Ź NEW[Xl.EventRep.local];
                    ev.connection Ź c;
                    ev.who Ź $noreply;
                    ev.key Ź $noreply;
                    IF tq=NIL THEN tq Ź Xl.CreateTQ[];
                    Xl.Enqueue[tq, overMatch.proc, overMatch.data, ev];
                    };
                };
            normalSingle => {
                <<--we didn't get the expected reply (or error)>>
                p.replyText Ź NewFakeErrorReply[p.sequenceNo, otherLocal]
                };
            specialDebugSingle => {
                <<--we have to check whether we got a reply or not>>
                IF p.data=$gotit
                    THEN NULL --normal case; looks like absence because we didn't remove acceptor yet 
                    ELSE {
                        p.replyText Ź NewFakeErrorReply[p.sequenceNo, otherLocal]
                        };
                };
            multiple => {
                IF p.data#doneWithMultiple THEN {
                    <<--Must abort the waiter>>
                    p.replyText Ź NewFakeErrorReply[p.sequenceNo, otherLocal]
                    };
                };
            ENDCASE => ERROR;
        NotifyReceiptOfReply[p];
        };

    UnexpectedReplyOrError: INTERNAL PROC [c: Connection, sequenceNumber: SequenceNo, replyText: Reply] = {
        IF ~c.alive THEN RETURN; --pending list may have been freed before reply arrived 
        SELECT replyText.fix[0] FROM 
            0 => { --error event
                <<<<a regular client error event, reported by the X server>>>>
                };
            1 => { --reply "event"
                <<--An un-expected reply>>
                <<--Could this be generated by a dying connection?  I'm not sure but that is why debugging this is optional.>>
                cPriv: REF ConnectionPrivateImplRec Ź c.cPriv;
                fix: REF PACKED ARRAY [0..32) OF BYTE Ź NEW[PACKED ARRAY [0..32) OF BYTE Ź replyText.fix];  
                debugTheNotExpectedReply Ź replyText;
                debugTheNotExpectedFix Ź fix;
                Atom.PutProp[$XlDebug, $XlDebug0, c];
                Atom.PutProp[$XlDebug, $XlDebug1, NEW[INT Ź sequenceNumber]];
                Atom.PutProp[$XlDebug, $XlDebug2, fix];
                WITH cPriv.debug SELECT FROM
                    da: REF DebugArray => {
                        <<copy: REF DebugArray Ź NEW[DebugArray Ź da­];  This copy used not to work correctly; I'm suspecting the C compiler but have no 
                        prove yet!!>>
                        copy: REF DebugArray Ź NEW[DebugArray];
                        FOR i: [0..debugArrayCnt) IN [0..debugArrayCnt) DO 
                            copy­[i] Ź da­[i] 
                            ENDLOOP;
                        Atom.PutProp[$XlDebug, $XlDebug3, copy];
                        WITH Atom.GetProp[$XlDebug, $DebugStream] SELECT FROM
                            s: IO.STREAM => {
                                idx: INT Ź (sequenceNumber MOD debugArrayCnt) + 2*debugArrayCnt; --make it positive enough that simple mod will work
                                IO.PutRope[s, "un-expected reply\ntext:"];
                                FOR i: INT IN [0..32) DO
                                    IO.PutF1[s, " %g", IO.int[fix[i]]]
                                    ENDLOOP;
                                IO.PutF1[s, "\nsequencenumber %g \n", IO.int[sequenceNumber]];
                                IO.PutF[s, "request codes:  %g %g %g\n", IO.int[da[(idx-1) MOD debugArrayCnt]], IO.int[da[idx MOD debugArrayCnt]], 
                                IO.int[da[(idx+1) MOD debugArrayCnt]]]
                                };
                            ENDCASE => {};
                        };
                    ENDCASE => { <<debugging this wasn't set up>> };
                IF debugSignalOnNotExpectedReply OR Atom.GetProp[$XlDebug, $SignalReplyNotExpected] # NIL THEN {
                    SIGNAL debugReplyNotExpected;
                    };
                };
            ENDCASE => ERROR; --Program logic should not call UnexpectedReplyOrError in this case
        QueueError[c, sequenceNumber, replyText];
        };

    QueueReply: ENTRY PROC [c: Connection, sequenceNumber: SequenceNo, replyText: Reply] ~ TRUSTED {
        <<Called from the event dipatcher loop only: therefore calls are in order of sequenceNumber>>
        i: REF ImplReplyStuffRep ~ c.replyStuff;
        <<--I tried to check for InOrderStrictly, but that might not be possible if 2**15 requests don't need replies.>>
        i.lastAnswerdSeq Ź sequenceNumber;
        IF i.generalWaiters>0 THEN BROADCAST i.gotGeneralReply;
        DO
            p: Acceptor Ź i.dequeuePoint;
            IF p=NIL THEN {
                UnexpectedReplyOrError[c, sequenceNumber, replyText];
                RETURN
                };
            IF p.sequenceNo=sequenceNumber THEN {
                ExpectedReply[c, p, replyText]; --might or might not dequeue p
                RETURN
                };
            IF InOrderStrictly[sequenceNumber, p.sequenceNo] THEN {
                <<--leave p alone!>>
                UnexpectedReplyOrError[c, sequenceNumber, replyText];
                RETURN
                };
            AbsenceOfReply[c, p];
            DeActivateAcceptor[i, p];
            ENDLOOP
        };

    doneWithMultiple: REF ~ NEW[INT Ź 0];

    FinishWithMultipleReplies: PUBLIC INTERNAL PROC [c: Connection, callback: ReplyGotProc, data: REF Ź NIL]  ~ TRUSTED {
        rp: REF ImplReplyStuffRep ~ c.replyStuff;
        p: Acceptor Ź NewAcceptor[rp, multiple];
        p.reportPartOfMultiple Ź callback;
        p.data Ź data;
        ActivateAcceptor[rp, p, c.sequenceNumber];
        FinishRequest[c];
        XlPrivate.HardFlushBuffer[c];
        [] Ź WaitForReplies[c, p];
        };

    FinishWithPartialDetailsNoErrors: PUBLIC INTERNAL PROC [c: Connection, details: Details Ź NIL] RETURNS [errors: REF 
    Xl.EventRep.errorNotify Ź NIL] = {
    <<--Like FinishWithDetailsNoErrors but uses only errorMatch and synchronous of details.>>
    <<--This is useful to implement multi-request commands.>>
        FinishRequest[c];
        IF details#NIL 
            THEN {
                details.sequenceNo Ź c.sequenceNumber;
                IF details.synchronous THEN {errors Ź FinishSynchToCheckForErrors[c]; RETURN};
                IF details.errorMatch#NIL THEN {
                    p: Acceptor Ź NewAcceptor[c.replyStuff, errorsAndOver];
                    p.errorMatch Ź details.errorMatch;
                    ActivateAcceptor[c.replyStuff, p, c.sequenceNumber];
                    DontWaitForReplies[c, p];
                    }
                }
            ELSE {
                IF c.synchCount>0 THEN errors Ź FinishSynchToCheckForErrors[c];
                };
        };

    InlineFinishWithDetailsNoErrors: INTERNAL PROC [c: Connection, details: Details Ź NIL] RETURNS [errors: REF Xl.EventRep.errorNotify 
    Ź NIL] = <<INLINE>> {
        FinishRequest[c];
        IF details#NIL 
            THEN {
                <<--note: c.synchCount is only consulted with details=NIL>>
                details.sequenceNo Ź c.sequenceNumber;
                IF details.synchronous THEN {errors Ź FinishSynchToCheckForErrors[c]; RETURN};
                IF details.errorMatch#NIL OR details.overMatch#NIL THEN {
                    p: Acceptor ~ NewAcceptor[c.replyStuff, errorsAndOver];
                    p.errorMatch Ź details.errorMatch;
                    p.overMatch Ź details.overMatch;
                    ActivateAcceptor[c.replyStuff, p, c.sequenceNumber];
                    DontWaitForReplies[c, p];
                    };
                IF details.flush=now THEN XlPrivate.HardFlushBuffer[c];
                }
            ELSE {
                IF c.synchCount>0 THEN errors Ź FinishSynchToCheckForErrors[c];
                };
        };

    FinishWithDetailsNoErrors: PUBLIC INTERNAL PROC [c: Connection, details: Details Ź NIL] RETURNS [errors: REF 
    Xl.EventRep.errorNotify Ź NIL] = {
        errors Ź InlineFinishWithDetailsNoErrors[c, details];
        };

    FinishWithDetails: PUBLIC INTERNAL PROC [c: Connection, details: Details Ź NIL] = {
        errors: REF Xl.EventRep.errorNotify Ź InlineFinishWithDetailsNoErrors[c, details];
        IF errors#NIL THEN XlPrivateErrorHandling.RaiseErrorEvent[errors]; 
        }; 

    FinishSynchToCheckForErrors: INTERNAL PROC [c: Connection] RETURNS [error: REF EventRep.errorNotify Ź NIL] ~ TRUSTED {
        <<--Use only when no replies are expected>>
        IF c.alive THEN {
            rp: REF ImplReplyStuffRep ~ c.replyStuff;
            clientReply: Reply;
            clientAcceptor, extraAcceptor: Acceptor;
            <<-->>
            clientAcceptor Ź NewAcceptor[rp, errorsAndOver];
            ActivateAcceptor[rp, clientAcceptor, c.sequenceNumber];
            <<-->>
            StartDirectRequest[c, 43, 0, 1]; --GetInputFocus
            FinishRequest[c];
            extraAcceptor Ź NewAcceptor[rp, ignoreAndFree];
            ActivateAcceptor[rp, extraAcceptor, c.sequenceNumber];
            XlPrivate.HardFlushBuffer[c];
            <<-->>
            clientReply Ź WaitForReplies[c, clientAcceptor];
            IF clientReply#NIL THEN {
                error Ź XlPrivateErrorHandling.NewErrorEvent[clientReply, c];
                DontWaitForReplies[c, extraAcceptor];
                RETURN;
                };
            <<DontWaitForReplies[c, extraAcceptor];>>
            [] Ź WaitForReplies[c, extraAcceptor];
            };
        };

    StartMainLoop: PUBLIC PROC [c: Connection] = {
        cp: REF ConnectionPrivateImplRec ~ c.cPriv;
        c.replyStuff Ź NewReplyStuff[];
        IF Xl.Alive[c] THEN { 
            ForkOps.Fork[ConnectionReader, c, Process.priorityClient3<<the user waits and looks at the terminal>>]; 
            };
        };

    TRUSTED {
        untracedZone Ź SafeStorage.GetUntracedZone[];
        };
    END.