<<>>
    <<SimpleStreamsImpl.mesa>>
        <<Copyright Ó 1988, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Christian Jacobi, August 26, 1988 11:12:22 am PDT>>
        <<Christian Jacobi, October 6, 1988 3:08:15 pm PDT>>

    DIRECTORY 
        Ascii, IO, EditedStream, RefTab, Rope, SafeStorage, SimpleStreams;

    SimpleStreamsImpl: CEDAR MONITOR
        IMPORTS EditedStream, IO, RefTab, SafeStorage
        EXPORTS SimpleStreams =
    BEGIN OPEN SimpleStreams; 

    TypeReg: TYPE = RECORD [type: SafeStorage.Type, p: CreateProcType];
    types: LIST OF TypeReg Ź NIL;  --there will be only a very small number of registered types 
    tab: RefTab.Ref Ź RefTab.Create[3]; --registered window systems
    default: REF Ź NIL;  --existence checked before assignment

    Find: PROC [ws: REF] RETURNS [found: REFŹNIL, proc: CreateProcTypeŹNIL] = {
        WITH RefTab.Fetch[tab, ws].val SELECT FROM
            pr: REF CreateProcType => {RETURN[ws, pr­]};
            ENDCASE => {};
        WITH ws SELECT FROM
            la: LIST OF ATOM => --recurse on elements of list
                FOR l: LIST OF ATOM Ź la, l.rest WHILE l#NIL DO
                    [found, proc] Ź Find[l.first];
                    IF found#NIL THEN RETURN;
                    ENDLOOP;
            lra: LIST OF REF ANY =>  --recurse on elements of list
                FOR l: LIST OF REF ANY Ź lra, l.rest WHILE l#NIL DO
                    [found, proc] Ź Find[l.first];
                    IF found#NIL THEN RETURN;
                    ENDLOOP;
            a: ATOM => RETURN; --prevent endcase: not worth going through types
            ENDCASE => {
                IF ws#NIL AND types#NIL THEN {
                    type: SafeStorage.Type Ź SafeStorage.GetReferentType[ws];
                    FOR l: LIST OF TypeReg Ź types, l.rest WHILE l#NIL DO
                        IF type=l.first.type THEN RETURN [ws, l.first.p];
                        ENDLOOP;
                    FOR l: LIST OF TypeReg Ź types, l.rest WHILE l#NIL DO
                        IF SafeStorage.EquivalentTypes[type, l.first.type] THEN RETURN [ws, l.first.p]; 
                        ENDLOOP;
                    };
                };
        };

    Create: PUBLIC PROC [header: Rope.ROPE Ź NIL, echo: BOOL Ź TRUE, windowSystem: REF Ź NIL] RETURNS [in, out, err: IO.STREAM, 
    hasEcho: BOOL] = {
        ws: REF Ź NIL; proc: CreateProcType Ź NIL;
        IF windowSystem#NIL THEN [ws, proc] Ź Find[windowSystem];
        IF proc=NIL THEN {
            [ws, proc] Ź Find[default];
            IF proc=NIL THEN proc Ź NoWhereCreate;
            };
        [in, out, err, hasEcho] Ź proc[header, echo, ws];  
        IF echo AND ~hasEcho THEN 
            in Ź EditedStream.Create[in: in, echoTo: out, deliverWhen: DeliverOnCrOrLf];
        IF err=NIL THEN err Ź out;
        };

    SetCurrentCreate: PUBLIC PROC [windowSystem: REF, scope: REF Ź NIL] = {
        ws: REF Ź NIL; proc: CreateProcType Ź NIL;
        [ws, proc] Ź Find[windowSystem];
        IF ws#NIL AND proc#NIL THEN default Ź ws;
        };

    ImplementCreate: PUBLIC ENTRY PROC [windowSystem: REF, create: CreateProcType, setCurrent: BOOL Ź TRUE] = {
        <<--ENTRY to protect the CONS'ing of type registrations>>
        ENABLE UNWIND => NULL;
        IF create#NIL THEN {
            WITH windowSystem SELECT FROM
                tr: REF SafeStorage.Type => types Ź CONS[TypeReg[tr­, create], types];
                ENDCASE => [] Ź RefTab.Store[tab, windowSystem, NEW[CreateProcType Ź create]];
            IF setCurrent THEN SetCurrentCreate[windowSystem];
            };
        };

    DeliverOnCrOrLf: EditedStream.DeliverWhenProc = {
        IF char = Ascii.DEL THEN {
            <<--prevent raising EditedStream.Rubout >>
            <<--(not an allowed error to be raised by streams; Pfui EditedStream)>>
            RETURN [appendChar: FALSE, activate: FALSE];
            }; 
        RETURN [appendChar: TRUE, activate: char = '\l OR char = '\r] 
        };

    NoWhereCreate: CreateProcType = {
        in Ź IO.noInputStream; out Ź err Ź IO.noWhereStream; hasEcho Ź echo;
        };

    ImplementCreate[NIL, NoWhereCreate, TRUE];
    END.