<<>>
    <<TEditTypeScriptImpl.mesa>>
        <<Copyright Ó 1984, 1985, 1987, 1988, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) January 23, 1986 0:47:05 am PST>>
        <<Michael Plass, September 24, 1991 2:18 pm PDT>>
        <<Willie-s, February 13, 1991 3:46 pm PST>>
        <<Doug Wyatt, April 23, 1992 11:21 am PDT>>
        <<>>
        <<*** is tsMaxSize what you want? ***>>
        <<>>
    DIRECTORY
        Ascii USING [BS, ControlW, DEL],
        InputFocus USING [GetInputFocus, SetInputFocus],
        List USING [Memb],
        Menus USING [AppendMenuEntry, CreateEntry, CreateMenu, Menu, MenuProc],
        MessageWindow USING [Append, Blink],
        NodeProps USING [GetProp],
        PFS USING [GetWDir, RopeFromPath],
        Process USING [CheckForAbort, Detach, EnableAborts, GetCurrent, MsecToTicks, SecondsToTicks, SetTimeout, Ticks],
        Rope USING [Cat, Concat, Fetch, FromChar, FromProc, FromRefText, Length, ROPE, Size, Substr],
        RuntimeError USING [UNCAUGHT],
        TEditCompile USING [minAvgLineLeading],
        TEditDocument USING [LineTable, LineTableRec, RecordViewerForRoot, Selection, SelectionRec, SpinAndLock, TEditDocumentData, 
        TEditDocumentDataRec, TSInfo, TSInfoRec, ttyChars, Unlock],
        TEditPrivate USING [ReloadTable, TEditNotifyProc],
        TEditInput USING [BadMouse, CommandProc, currentEvent, DontDoIt, FreeTree, InterpretAtom, Register, ResetInputStuff, SaveCoords],
        TEditInputOps USING [EditFailed],
        TEditLocks USING [Lock, LockRef, Unlock],
        TEditProfile USING [editTypeScripts],
        TEditRefresh USING [ScrollToEndOfDoc],
        TEditSelection USING [Alloc, Copy, Free, InsertionPoint, LockSel, MakePointSelection, MakeSelection, pSel, SelectionRoot, 
        SetSelLooks, UnlockSel],
        TEditSplit USING [Split],
        TEditTouchup USING [LockAfterScroll, UnlockAfterRefresh],
        TextEdit USING [DeleteText, DocFromNode, FromRope, ReplaceByRope, Size],
        TextLooks USING [allLooks, noLooks, ModifyLooks],
        TextNode USING [FirstChild, LastLocWithin, Location, Ref, RefTextNode, StepForward],
        Tioga USING [CharSet, Looks, PropList],
        TIPUser USING [RegisterTIPPredicate, TIPPredicate, TIPScreenCoords, TIPTable],
        TypeScript USING [],
        ViewerClasses USING [InitProc, Lock, NotifyProc, Viewer, ViewerClass, ViewerClassRec, ViewerRec],
        ViewerGroupLocks USING [CallRootAndLinksUnderWriteLock],
        ViewerOps USING [AddProp, CreateViewer, DestroyViewer, FetchProp, FetchViewerClass, RegisterViewerClass, SetMenu];

    TEditTypeScriptImpl: CEDAR MONITOR
        IMPORTS InputFocus, List, Menus, MessageWindow, NodeProps, PFS, Process, Rope, RuntimeError, TEditDocument, TEditPrivate, 
        TEditInput, TEditInputOps, TEditLocks, TEditProfile, TEditRefresh, TEditSelection, TEditSplit, TEditTouchup, TextEdit, 
        TextLooks, TextNode, TIPUser, ViewerGroupLocks, ViewerOps
        EXPORTS
            TypeScript,
                <<Most things>>
            TEditPrivate
                <<TypeScriptNotifyProc, CaretAtEnd, typeScriptTIP, ReloadTypeScriptTipTable>>
        = BEGIN

        ROPE: TYPE = Rope.ROPE;
        TS: TYPE = ViewerClasses.Viewer;

        CharSet: TYPE ~ Tioga.CharSet;
        Looks: TYPE ~ Tioga.Looks;
        PropList: TYPE ~ Tioga.PropList;

        TSInfo: TYPE ~ TEditDocument.TSInfo;

        Destroyed: PUBLIC ERROR [ts: TS] = CODE;

        Create: PUBLIC PROC [info: ViewerClasses.ViewerRec, paint: BOOL Ź TRUE] RETURNS [ts: TS] = {  
            tdd: TEditDocument.TEditDocumentData Ź NewData[];
            info.data Ź tdd;
            ts Ź ViewerOps.CreateViewer[$Typescript, info, paint];
            };

        IsATypeScript: PUBLIC PROC [ts: TS] RETURNS [yes: BOOL] = {
            RETURN [ts # NIL AND ts.class.flavor = $Typescript];
            };

        Destroy: PUBLIC PROC [ts: TS] = {
            ViewerOps.DestroyViewer[ts];
            };

        Reset: PUBLIC PROC [ts: TS] = {
            ts.class.init[ts];
            };
            <<>>
        NewData: PROC [self: ViewerClasses.Viewer Ź NIL] RETURNS [tdd: TEditDocument.TEditDocumentData] = {
            tdd Ź NEW[TEditDocument.TEditDocumentDataRec];
            [] Ź TEditDocument.SpinAndLock[tdd, "TEditTypeScriptImplNewData"];
            { nLines: NAT ~ MAX[2, (IF self=NIL THEN 0 ELSE (self.ch/TEditCompile.minAvgLineLeading))+1];
                lineTable: TEditDocument.LineTable ~ NEW[TEditDocument.LineTableRec[nLines]];
                lineTable.lastLine Ź 0; lineTable.lastY Ź 0;
                tdd.lineTable Ź lineTable;
                };
            tdd.tsInfo Ź NEW[TEditDocument.TSInfoRec];
            tdd.text Ź TextEdit.DocFromNode[TextEdit.FromRope[""]];
            TEditDocument.Unlock[tdd];
            TRUSTED {
                Process.EnableAborts[@tdd.tsInfo.iIncr];
                    <<so can test if destroyed>>
                Process.SetTimeout[@tdd.tsInfo.iIncr, Process.SecondsToTicks[10]];
                };
            };

        InitTypeScriptDocument: ViewerClasses.InitProc = {  
            tdd: TEditDocument.TEditDocumentData;
            InitTddText: PROC = {
                IF tdd.text # NIL THEN TEditInput.FreeTree[tdd.text];
                tdd.text Ź TextEdit.DocFromNode[TextEdit.FromRope[""]] 
                };
            InitLineTable: PROC = {
                tdd.lineTable.lastLine Ź 0;
                tdd.lineTable[0].pos Ź [TextNode.FirstChild[tdd.text], 0] 
                };
            IF InputFocus.GetInputFocus[].owner=self THEN InputFocus.SetInputFocus[];
            IF self.link#NIL THEN {
                <<make sure another link didn't already init>>
                <<and if so, copy that data>>
                otherInit: ViewerClasses.Viewer Ź NIL;
                otherTdd: TEditDocument.TEditDocumentData;
                tdd Ź NARROW[self.data];
                IF tdd = NIL THEN RETURN;
                [] Ź TEditDocument.SpinAndLock[tdd, "InitTypeScriptDocument"];
                FOR v: ViewerClasses.Viewer Ź self.link, v.link UNTIL v= NIL OR v=self DO
                    IF ~v.newVersion THEN {otherInit Ź v; EXIT};
                    ENDLOOP;
                IF otherInit=NIL OR (otherTdd Ź NARROW[otherInit.data]) = NIL
                    THEN InitTddText[]
                        <<we're first>>
                    ELSE tdd.text Ź otherTdd.text;
                        <<somebody else already did the init>>
                InitLineTable[];
                }
            ELSE IF self.data=NIL THEN { -- first time we've seen this viewer
                self.data Ź tdd Ź (IF self.parent=NIL THEN NewData[] ELSE NewData[self]);
                IF tdd = NIL THEN RETURN;
                [] Ź TEditDocument.SpinAndLock[tdd, "InitTypeScriptDocument"] 
                }
            ELSE {
                <<old viewer getting re-initialised>>
                tdd Ź NARROW[self.data];
                IF tdd = NIL THEN RETURN;
                [] Ź TEditDocument.SpinAndLock[tdd, "InitTypeScriptDocument"];
                InitTddText[];
                InitLineTable[];
                };
            IF self.column#static AND self.parent=NIL THEN
                ViewerOps.SetMenu[self, typescriptMenu, FALSE];
            TEditDocument.RecordViewerForRoot[self, tdd.text];
            TEditDocument.Unlock[tdd];
            };

    <<TTY PUT ROUTINES>>

        aLittleWhile: Process.Ticks = Process.MsecToTicks[50];
        aLongerWhile: Process.Ticks = Process.MsecToTicks[5000];
        untilTimesOutInALittleWhile: CONDITION;
        dontWait: BOOL Ź FALSE;
        WaitForEditRepaintProcess: INTERNAL PROC[ts: TS] = {
            WHILE editRepaintProcess#NIL DO
                IF currentTS # ts THEN RETURN; -- no need to wait for editRepaintProcess
                dontWait Ź TRUE;
                NOTIFY untilTimesOutInALittleWhile; -- no need to wait for a little while
                WAIT repaintDone;
                dontWait Ź FALSE;
                ENDLOOP;
            };

        PutChar: PUBLIC PROC [ts: TS, char: CHAR] = {
            <<IF char=1C THEN { BackSpace[ts]; RETURN }; -- This should not be necessary; clients should call BackSpace>>
            Process.CheckForAbort[];
            PutCharEntry[ts, char ! ABORTED => GO TO abort];
            EXITS abort => ERROR ABORTED;
            };

        PutCharEntry: ENTRY PROC [ts: TS, char: CHAR] = {
            ENABLE UNWIND => NULL; -- release lock
            count: INTEGER Ź 0;
            IF (editRepaintProcess#NIL AND currentTS#ts) THEN {
                <<wait to flush buffer>>
                WHILE editRepaintProcess#NIL DO
                    Process.CheckForAbort[];
                    WAIT repaintDone;
                    ENDLOOP;
                };
            currentTS Ź ts;
            WHILE inputBuffer.length>=bufferMaxlen DO
                IF (count Ź count+1) > 10 THEN {
                    <<waited long enough>>
                    overflowRope Ź Rope.Concat[overflowRope, Rope.FromRefText[inputBuffer]];
                    inputBuffer.length Ź 0;
                    EXIT 
                    };
                BROADCAST untilTimesOutInALittleWhile; -- wake up the repaint process
                WAIT bufferClear;
                ENDLOOP;
            inputBuffer[inputBuffer.length] Ź char;
            inputBuffer.length Ź inputBuffer.length + 1;
            IF editRepaintProcess = NIL THEN TRUSTED {
                Process.Detach[editRepaintProcess Ź FORK Repaint[ts]];
                };
            };

        BackSpace: PUBLIC ENTRY PROC [ts: TS, count: INT Ź 1] = {  
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            root: TextNode.Ref;
            selLock: BOOL;
            lockRef: TEditLocks.LockRef;
            Cleanup: PROC = {
                IF lockRef # NIL THEN { TEditLocks.Unlock[root]; lockRef Ź NIL };
                IF selLock THEN TEditSelection.UnlockSel[primary] 
                };
            IF tdd # NIL AND count > 0 AND tdd.tsInfo#NIL THEN {
                ENABLE UNWIND => Cleanup;
                flush: TextNode.Location;
                node: TextNode.RefTextNode;
                root Ź tdd.text;
                WaitForEditRepaintProcess[ts];
                TEditSelection.LockSel[primary, "TEditTypeScriptImplBackSpace"];
                <<see if pSel is in this typescript>>
                IF NOT (selLock Ź TEditSelection.SelectionRoot[TEditSelection.pSel]=root) THEN
                TEditSelection.UnlockSel[primary];
                lockRef Ź TEditLocks.Lock[root, "TEditTypeScriptImplBackSpace"];
                flush Ź TextNode.LastLocWithin[root];
                IF (node Ź flush.node)=NIL THEN GOTO Bad;
                IF (count Ź MIN[count,flush.where]) <= 0 THEN GOTO Bad;
                flush.where Ź flush.where-count;
                TextEdit.DeleteText[root, node, flush.where, count, TEditInput.currentEvent];
                IF selLock THEN FixPSel[ts, [flush.node, flush.where+count], flush];
                Cleanup[];
                EXITS Bad => { Cleanup[]; TEditInputOps.EditFailed[] };
                } 
            };

        PutRope: PUBLIC PROC [ts: TS, rope: Rope.ROPE] = {
            FOR n: INT IN [0..Rope.Length[rope]) DO
                PutChar[ts, Rope.Fetch[rope, n]];
                ENDLOOP;
            };

        PutText: PUBLIC PROC [ts: TS, text: REF READONLY TEXT, start: INTEGER Ź 0, stopPlusOne: INTEGER Ź LAST[INTEGER]] = {
            IF text#NIL THEN FOR n: INTEGER IN [start..MIN[text.length, stopPlusOne]) DO
                PutChar[ts, text[n]];
                ENDLOOP;
            };

        AddLooks: PROC [ts: TS, look: CHAR] = {
            remove, add: Looks Ź TextLooks.noLooks;
            SELECT look FROM
                IN['a..'z] => add[look] Ź TRUE;
                '  => remove Ź TextLooks.allLooks; -- blank means reset
                ENDCASE;
            ModifyLooks[ts: ts, remove: remove, add: add];
            };

        RemoveLooks: PROC [ts: TS, look: CHAR] = {
            IF look IN ['a..'z] THEN {
                remove: Looks Ź TextLooks.noLooks;
                remove[look] Ź TRUE;
                ModifyLooks[ts: ts, remove: remove, add: TextLooks.noLooks];
                };
            };


        Do: ENTRY PROC [ts: TS, action: PROC[info: TSInfo]] ~ {
            ENABLE UNWIND => NULL; -- release lock
            WITH ts.data SELECT FROM
                tdd: TEditDocument.TEditDocumentData => {
                    WaitForEditRepaintProcess[ts];
                    action[tdd.tsInfo];
                    };
                ENDCASE;
            };

        ChangeLooks: PUBLIC PROC [ts: TS, look: CHAR] = {
            <<look in 'a..'z means add; in 'A..'Z means remove; blank means remove all looks>>
            remove, add: Looks Ź TextLooks.noLooks;
            SELECT look FROM
                IN ['a..'z] => add[look] Ź TRUE;
                IN ['A..'Z] => remove[look+('a-'A)] Ź TRUE;
                = '  => remove Ź TextLooks.allLooks; -- blank means reset
                ENDCASE;
            ModifyLooks[ts: ts, remove: remove, add: add];
            };

        ModifyLooks: PUBLIC PROC [ts: TS, remove, add: Looks] ~ {
            InnerModifyLooks: PROC[info: TSInfo] ~ {
                info.looks Ź TextLooks.ModifyLooks[old: info.looks, remove: remove, add: add];
                };
            Do[ts, InnerModifyLooks];
            };

        SetLooks: PUBLIC PROC [ts: TS, looks: Looks] ~ {
            ModifyLooks[ts: ts, remove: TextLooks.allLooks, add: looks];
            };

        GetLooks: PUBLIC PROC [ts: TS] RETURNS [looks: Looks Ź TextLooks.noLooks] ~ {
            InnerGetLooks: PROC[info: TSInfo] ~ { looks Ź info.looks };
            Do[ts, InnerGetLooks];
            };

        SetCharSet: PUBLIC PROC [ts: TS, charSet: CharSet] ~ {
            InnerSetCharSet: PROC[info: TSInfo] ~ { info.charSet Ź charSet };
            Do[ts, InnerSetCharSet];
            };

        GetCharSet: PUBLIC PROC [ts: TS] RETURNS [charSet: CharSet Ź 0] ~ {
            InnerGetCharSet: PROC[info: TSInfo] ~ { charSet Ź info.charSet };
            Do[ts, InnerGetCharSet];
            };

        SetCharProps: PUBLIC PROC [ts: TS, charProps: PropList] ~ {
            InnerSetCharProps: PROC[info: TSInfo] ~ { info.charProps Ź charProps };
            Do[ts, InnerSetCharProps];
            };

        GetCharProps: PUBLIC PROC [ts: TS] RETURNS [charProps: PropList Ź NIL] ~ {
            InnerGetCharProps: PROC[info: TSInfo] ~ { charProps Ź info.charProps };
            Do[ts, InnerGetCharProps];
            };

        Flush: PUBLIC ENTRY PROC [ts: TS] = {
            ENABLE UNWIND => NULL; -- release lock
            IF ts # currentTS THEN RETURN;
            WaitForEditRepaintProcess[ts] 
            };

    <<BACKGROUND UPDATES>>

        editRepaintProcess: PROCESS Ź NIL;
        repaintDone: CONDITION;
        bufferClear: CONDITION;
        bufferMaxlen: CARDINAL = 64;
        inputBuffer: REF TEXT Ź NEW[TEXT[bufferMaxlen]];
        overflowRope: Rope.ROPE;
        currentTS: TS Ź NIL;
        RepaintDone: ENTRY PROC = {
            IF editRepaintProcess = Process.GetCurrent[] THEN editRepaintProcess Ź NIL;
            BROADCAST repaintDone;
            };

        RacyRepaintDone: PROC = {
            <<Called only when an uncaught error occurs - not an entry proc because that can deadlock>>
            IF editRepaintProcess = Process.GetCurrent[] THEN editRepaintProcess Ź NIL;
            <<Rely on  repaintDone to time out>>
            };

        InternalClearRepaint: INTERNAL PROC = {
            IF editRepaintProcess = Process.GetCurrent[] THEN editRepaintProcess Ź NIL;
            BROADCAST repaintDone;
            };

        Repaint: PROC [ts: TS] = {
            <<Cannot make this an ENTRY procedure since must lock selection and document before enter the monitor.  Else have deadlock with 
            Copy to typescript which gets locks before calling InputRope.>>
            root: TextNode.Ref;
            pos: TextNode.Location;
            lockRef: TEditLocks.LockRef Ź NIL;
            selLock, continue: BOOL Ź FALSE;
            CheckForAutoScroll: PROC [ts: TS] = {
                prop: REF BOOL;
                tdd: TEditDocument.TEditDocumentData Ź NARROW[ts.data];
                PosIsVisible: PROC [] RETURNS [BOOL] = {
                    lines: TEditDocument.LineTable = tdd.lineTable;
                    IF lines[lines.lastLine].pos.where+lines[lines.lastLine].nChars >= pos.where THEN
                        RETURN [TRUE];
                    RETURN [FALSE] 
                    };
                WITH ts.data SELECT FROM
                    tdd: TEditDocument.TEditDocumentData => {
                        IF TEditTouchup.LockAfterScroll[tdd, "TEditTypeScriptImplRepaint"] THEN {{
                            ENABLE UNWIND => TEditTouchup.UnlockAfterRefresh[tdd];
                            IF (prop Ź NARROW[ViewerOps.FetchProp[ts, $AutoScrollTypescript]]) = NIL THEN
                                ViewerOps.AddProp[ts, $AutoScrollTypescript, prop Ź NEW[BOOL]];
                            prop­ Ź PosIsVisible[]};
                            TEditTouchup.UnlockAfterRefresh[tdd] 
                            };
                        };
                    ENDCASE;
                };
            Cleanup: PROC = {
                IF lockRef # NIL THEN TEditLocks.Unlock[root]; lockRef Ź NIL;
                IF selLock THEN TEditSelection.UnlockSel[primary]; selLock Ź FALSE 
                };
            DoAutoScroll: PROC [ts: TS] = {
                prop: REF BOOL = NARROW[ViewerOps.FetchProp[ts, $AutoScrollTypescript]];
                IF prop#NIL AND prop­ THEN TEditRefresh.ScrollToEndOfDoc[ts, TRUE] 
                };
            WaitForMoreInput: ENTRY PROC RETURNS [BOOL] = {
                ENABLE UNWIND => NULL;
                IF overflowRope=NIL AND inputBuffer.length<bufferMaxlen THEN
                IF dontWait THEN NULL ELSE WAIT untilTimesOutInALittleWhile;
                IF overflowRope=NIL AND inputBuffer.length=0 THEN {
                    InternalClearRepaint[];
                    RETURN [FALSE]
                    }; -- no new input
                RETURN [TRUE] 
                };
            WITH ts.data SELECT FROM
                tdd: TEditDocument.TEditDocumentData => {
                    ENABLE {
                        UNWIND => Cleanup[];
                        ABORTED => GOTO Quit;
                        RuntimeError.UNCAUGHT => {Cleanup[]; RacyRepaintDone[]; REJECT};
                            <<Make some attempt to give back the locks and restart things (also REJECT)>>
                        };
                    CheckAll: PROC = {
                        lockRef Ź TEditLocks.Lock[root, "TEditTypeScriptImplRepaint", read]; 
                        pos Ź TextNode.LastLocWithin[root];
                        CheckForAutoScroll[ts];
                        FOR v: ViewerClasses.Viewer Ź ts.link, v.link UNTIL v = NIL OR v=ts DO
                            CheckForAutoScroll[v];
                            ENDLOOP;
                        TEditLocks.Unlock[root];
                        lockRef Ź NIL;
                        };
                    ScrollAll: PROC = {
                        DoAutoScroll[ts];
                        FOR v: ViewerClasses.Viewer Ź ts.link, v.link UNTIL v = NIL OR v=ts DO
                            DoAutoScroll[v];
                            ENDLOOP;
                        };
                    IF (root Ź tdd.text) = NIL THEN GO TO Quit;
                    ViewerGroupLocks.CallRootAndLinksUnderWriteLock[CheckAll, ts];
                    DO
                        TEditSelection.LockSel[primary, "TEditTypeScriptImplRepaint"];
                        <<see if pSel is in this typescript>>
                        IF NOT (selLock Ź TEditSelection.SelectionRoot[TEditSelection.pSel]=root) THEN
                            TEditSelection.UnlockSel[primary];
                        lockRef Ź TEditLocks.Lock[root, "TEditTypeScriptImplRepaint"];
                        continue Ź MakeEdits[ts, selLock];
                        Cleanup[];
                        ViewerGroupLocks.CallRootAndLinksUnderWriteLock[ScrollAll, ts];
                        IF ~continue OR ~WaitForMoreInput[] THEN EXIT;
                        ENDLOOP;
                    EXITS Quit => Cleanup[];
                    };
                ENDCASE;
            RepaintDone[];
            };

        updateSel: TEditDocument.Selection Ź NEW[TEditDocument.SelectionRec];
        tsMaxSize: INT Ź INT.LAST; -- ***** temporary (?) for PCedar *****

        MakeEdits: ENTRY PROC [ts: TS, selLock: BOOL] RETURNS [continue: BOOL] = {  
            ENABLE UNWIND => NULL;
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            info: TSInfo;
            node: TextNode.RefTextNode;
            pos: TextNode.Location;
            rope: ROPE Ź NIL;
            ropeFiledSizeRef: REF INT Ź NIL;
            ropeFiledSize: INT Ź 0;
            IF tdd=NIL THEN {
                overflowRope Ź NIL;
                inputBuffer.length Ź 0;
                InternalClearRepaint[];
                RETURN [FALSE];
                };
            IF overflowRope=NIL AND inputBuffer.length=0 THEN {
                InternalClearRepaint[];
                RETURN [FALSE];
                };
            info Ź tdd.tsInfo;
            pos Ź TextNode.LastLocWithin[tdd.text];
            node Ź pos.node;
            rope Ź overflowRope;
            IF inputBuffer.length>0 THEN {
                rope2: ROPE ~ Rope.FromRefText[inputBuffer];
                rope Ź IF rope=NIL THEN rope2 ELSE Rope.Concat[rope, rope2];
                };
            [] Ź TextEdit.ReplaceByRope[root: tdd.text, dest: node, rope: rope, 
            start: pos.where, len: 0, looks: info.looks, charSet: info.charSet, charProps: info.charProps, event: 
            TEditInput.currentEvent];
            overflowRope Ź NIL;
            inputBuffer.length Ź 0;
            ropeFiledSizeRef Ź NARROW[NodeProps.GetProp[n: tdd.text, name: $RopeFiledSize]];
            ropeFiledSize Ź (IF ropeFiledSizeRef # NIL THEN ropeFiledSizeRef­ ELSE 0);
            <<IF Rope.Size[node.rope]-ropeFiledSize > tsMaxSize THEN {
                <<To avoid consuming a lot of VM, make the rope into a ropefile.>>
                ENABLE PFS.Error => GOTO ForgetIt;
                ropeSize: INT ~ Rope.Size[node.rope];
                stream: IO.STREAM ~ PFS.StreamOpen[fileName: "[]<>Temp>TypescriptOverflow.txt", accessOptions: $create, createByteCount: 
                ropeSize-ropeFiledSize, streamBufferParms: [1, 2]];
                IF ropeFiledSizeRef = NIL THEN {
                    ropeFiledSizeRef Ź NEW[INT Ź 0];
                    NodeProps.PutProp[n: tdd.text, name: $RopeFiledSize, value: ropeFiledSizeRef];
                    };
                IF ropeFiledSize NOT IN [0..ropeSize] THEN ropeFiledSizeRef­ Ź ropeFiledSize Ź 0;
                    <<Must have happened because somebody edited the typescript>>
                IO.PutRope[stream,
                    Rope.Substr[base: node.rope, start: ropeFiledSize, len: ropeSize-ropeFiledSize]
                    ];
                IO.Flush[stream];
                node.rope Ź Rope.Concat[
                    Rope.Substr[base: node.rope, start: 0, len: ropeFiledSize],
                    RopeFile.FromStream[stream: stream, start: 0, len: ropeSize-ropeFiledSize, bufSize: 512, buffers: 3]
                    ];
                ropeFiledSizeRef­ Ź ropeSize;
                SafeStorage.ReclaimCollectibleObjects[suspendMe: FALSE];
                EXITS ForgetIt => NULL;
                };>>
            IF selLock THEN FixPSel[ts, pos, TextNode.LastLocWithin[tdd.text]];
            BROADCAST bufferClear;
            RETURN [TRUE];
            };

        FixPSel: PROC [ts: TS, pos, newPos: TextNode.Location] = {  
            FixSel: PROC = {
                tSel: TEditDocument.Selection Ź TEditSelection.Alloc[];
                TEditSelection.Copy[source: TEditSelection.pSel, dest: tSel];
                TEditSelection.MakePointSelection[tSel, newPos];
                TEditSelection.SetSelLooks[TEditSelection.pSel];
                TEditSelection.Free[tSel] 
                };
            IF TEditSelection.pSel.granularity=point AND TEditSelection.pSel.end.pos.where >= pos.where THEN
            IF ts=TEditSelection.pSel.viewer
                THEN FixSel[]
                ELSE FOR v: TS Ź ts.link, v.link UNTIL v = NIL OR v=ts DO
                    IF v=TEditSelection.pSel.viewer THEN { FixSel[]; EXIT };
                    ENDLOOP 
            };


    <<KEYBOARD INPUT>>
        <<Exported to TEditPrivate>>
        CaretAtEnd: PUBLIC PROC [sel: TEditDocument.Selection] RETURNS [yes: BOOL] = {
            root: TextNode.Ref = TEditSelection.SelectionRoot[sel];
            IF root=NIL THEN RETURN [FALSE]; -- not a valid selection
            IF sel.granularity # point THEN RETURN [FALSE]; -- not a point selection
            [] Ź TEditLocks.Lock[root, "TEditTypeScriptImplCaretAtEnd", read];
            <<need lock to synch with edits to typescript>>
            { caret: TextNode.Location = TEditSelection.InsertionPoint[sel];
                node: TextNode.Ref = caret.node;
                IF node=NIL OR TextNode.StepForward[node] # NIL THEN yes Ź FALSE
                    ELSE IF caret.where # TextEdit.Size[node] THEN yes Ź FALSE
                    ELSE yes Ź TRUE;
                TEditLocks.Unlock[root] 
                }
            };
        TypeScriptNotifyProc: PUBLIC ViewerClasses.NotifyProc = {
            IF TEditProfile.editTypeScripts THEN {
                tdd: TEditDocument.TEditDocumentData = NARROW[self.data];
                IF tdd = NIL THEN RETURN;
                IF TEditSelection.SelectionRoot[TEditSelection.pSel]=tdd.text
                AND (NOT CaretAtEnd[TEditSelection.pSel] OR List.Memb[$PARAM, input]) THEN {
                    <<Caret in this typescript, but not at end.  So treat like edit of normal Tioga doc.>>
                    TEditPrivate.TEditNotifyProc[self, input]; RETURN 
                    }
                };
            TEditInput.ResetInputStuff[];
            FOR params: LIST OF REF ANY Ź input, params.rest UNTIL params=NIL DO
                z: REF ANY ~ params.first;
                WITH z SELECT FROM
                    z: REF CHAR => {ForceInsertSel[self]; InputChar[self, z­]};
                    z: ATOM => {
                        Flush[self];
                        InterpretAtom[self, z ! TEditInput.DontDoIt, TEditInput.BadMouse => EXIT] 
                        };
                    z: Rope.ROPE => {ForceInsertSel[self]; InputRope[self, z] };
                    z: REF INT => {
                        tdd: TEditDocument.TEditDocumentData = NARROW[self.data];
                        IF tdd # NIL THEN tdd.tsInfo.intParam Ź z­ 
                        };
                    z: REF TEXT => {ForceInsertSel[self];
                        FOR n: CARDINAL IN [0..z.length) DO InputChar[self, z[n]]; ENDLOOP
                        };
                    z: TIPUser.TIPScreenCoords => TEditInput.SaveCoords[z.mouseX, self.ch-z.mouseY];
                    ENDCASE => IF z#NIL THEN { -- DKW: assume NIL was a ROPE
                    MessageWindow.Append["Unknown input given to Tioga typescript interpreter.", TRUE];
                    MessageWindow.Blink[] 
                    };
                ENDLOOP;
            };

        ForceInsertSel: PROC [ts: TS] = {  
            IF TEditSelection.pSel.viewer#ts OR (TEditSelection.pSel.granularity=point AND TEditSelection.pSel.insertion=before) THEN RETURN;
            TEditSelection.LockSel[primary, "TEditTypeScriptForceInsertSel"]; { ENABLE UNWIND => TEditSelection.UnlockSel[primary];
                IF TEditSelection.pSel.viewer=ts AND (TEditSelection.pSel.granularity#point OR TEditSelection.pSel.insertion#before) THEN {
                    tSel: TEditDocument.Selection  Ź TEditSelection.Alloc[];
                    TEditSelection.Copy[source: TEditSelection.pSel, dest: tSel];
                    tSel.insertion Ź before;
                    tSel.granularity Ź point;
                    tSel.start.pos Ź tSel.end.pos Ź TextNode.LastLocWithin[tSel.data.text];
                    TEditSelection.MakeSelection[new: tSel];
                    TEditSelection.Free[tSel];
                    };
                TEditSelection.UnlockSel[primary];
                } 
            };

        InterpretAtom: PROC [viewer: ViewerClasses.Viewer, atom: ATOM] = {   
            SELECT atom FROM
                $Abort => SetUserAbort[viewer];
                $ApplyCaretLook, $ApplyLook, $RemoveCaretLook, $RemoveLook => {
                    tdd: TEditDocument.TEditDocumentData = NARROW[viewer.data];
                    IF tdd = NIL THEN RETURN;
                    TEditPrivate.TEditNotifyProc[viewer, LIST[NEW[INT Ź tdd.tsInfo.intParam]]];
                    TEditInput.InterpretAtom[viewer,atom] 
                    };
                $BackSpace => {ForceInsertSel[viewer]; InputChar[viewer, Ascii.BS]};
                $BackWord => {ForceInsertSel[viewer]; InputChar[viewer, Ascii.ControlW]};
                $ClearTypeScriptLooks => SetLooks[viewer, TextLooks.noLooks];
                $Delete => {ForceInsertSel[viewer]; InputChar[viewer, Ascii.DEL]};
                $Paste => {ForceInsertSel[viewer]; TEditInput.InterpretAtom[viewer, atom]};
                ENDCASE => TEditInput.InterpretAtom[viewer,atom];
            };

        NumberToLook: PROC [viewer: ViewerClasses.Viewer] RETURNS [l: CHAR] = {
            tdd: TEditDocument.TEditDocumentData = NARROW[viewer.data];
            IF tdd = NIL THEN RETURN['z];
            RETURN['a+tdd.tsInfo.intParam] 
            };

        ApplyTypeScriptLook: TEditInput.CommandProc = {
            WaitUntilIdle[viewer]; AddLooks[viewer, NumberToLook[viewer]] 
            };

        RemoveTypeScriptLook: TEditInput.CommandProc = {
            WaitUntilIdle[viewer]; RemoveLooks[viewer, NumberToLook[viewer]] 
            };

        InsertRopeAtFrontOfBuffer: PUBLIC ENTRY PROC [ts: TS, rope: Rope.ROPE] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                inputRope Ź Rope.Concat[rope, Rope.Substr[inputRope, inputLoc]];
                inputLoc Ź 0;
                BROADCAST iIncr;
                };
            };

        InsertCharAtFrontOfBuffer: PUBLIC ENTRY PROC [ts: TS, char: CHAR] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                inputRope Ź Rope.Concat[Rope.FromChar[char], Rope.Substr[inputRope, inputLoc]];
                inputLoc Ź 0;
                BROADCAST iIncr;
                };
            };

        FlushInputChars: INTERNAL PROC [tdd: TEditDocument.TEditDocumentData] = {  OPEN tdd.tsInfo;
            num: INT = IF iQp > oQp THEN iQp-oQp ELSE TEditDocument.ttyChars-iQp+oQp;
            Char: PROC RETURNS [c: CHAR] = {
                c Ź input[oQp]; oQp Ź (oQp+1) MOD TEditDocument.ttyChars 
                };
            rope: Rope.ROPE;
            rope Ź Rope.FromProc[num, Char];
            inputRope Ź Rope.Concat[inputRope, rope];
            iQp Ź oQp Ź 0 
            };

        InputRope: ENTRY PROC [ts: TS, rope: Rope.ROPE] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                IF iQp # oQp THEN FlushInputChars[tdd];
                inputRope Ź Rope.Concat[inputRope, rope];
                BROADCAST iIncr;
                };
            };

        InputChar: ENTRY PROC [ts: TS, char: CHAR] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                newiQp: INTEGER = (iQp+1) MOD TEditDocument.ttyChars;
                IF newiQp = oQp THEN FlushInputChars[tdd];
                input[iQp] Ź char; iQp Ź newiQp;
                BROADCAST iIncr;
                };
            };

    <<TTY GET ROUTINES>>
        GetChar: PUBLIC ENTRY PROC [ts: TS] RETURNS [char: CHAR] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            size: INT;
            IF tdd = NIL THEN RETURN['a]  -- Hmm. used to return garbage. PDR
            ELSE { OPEN tdd.tsInfo;
                WHILE inputLoc >= (size Ź Rope.Size[inputRope]) AND iQp = oQp DO
                    waitingInGetChar Ź TRUE;
                    WAIT iIncr;
                    waitingInGetChar Ź FALSE;
                    IF ts.destroyed THEN RETURN WITH ERROR Destroyed[ts];
                    <<raise error if viewer destroyed.  Timeout for condition is set above>>
                    ENDLOOP;
                IF inputLoc < size THEN { -- get char from rope
                    char Ź Rope.Fetch[inputRope, inputLoc];
                    IF (inputLoc Ź inputLoc+1)=size THEN { -- have finished this rope
                        inputLoc Ź 0; inputRope Ź NIL 
                        }
                    }
                ELSE { -- get from buffer
                    char Ź input[oQp]; oQp Ź (oQp+1) MOD TEditDocument.ttyChars 
                    };
                };
            };

        CharsAvailable: PUBLIC ENTRY PROC [ts: TS] RETURNS [BOOL] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd = NIL THEN RETURN [FALSE]
            ELSE { OPEN tdd.tsInfo;
                IF tdd.tsInfo=NIL THEN RETURN [FALSE]; -- not a typescript
                RETURN[inputLoc < Rope.Size[inputRope] OR iQp#oQp];
                };
            };

        TypeIn: PUBLIC PROC [ts: TS, input: REF ANY]
            = {ts.class.notify[ts, LIST[input]]};
            <<Simulate user typein to a typescript>>
            <<can be REF CHAR, ROPE, REF TEXT, or ATOM (be careful).>>

        WaitUntilCharsAvail: PUBLIC ENTRY PROC [ts: TS] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                IF tdd.tsInfo=NIL THEN RETURN; -- not a typescript
                WHILE inputLoc >= Rope.Size[inputRope] AND iQp = oQp DO
                    waitingInGetChar Ź TRUE;
                    WAIT iIncr;
                    waitingInGetChar Ź FALSE;
                    IF ts.destroyed THEN RETURN WITH ERROR Destroyed[ts];
                    <<raise error if viewer destroyed.  Timeout for condition is set above>>
                    ENDLOOP;
                };
            };

        WaitUntilIdle: PUBLIC ENTRY PROC [ts: TS] = {
            ENABLE UNWIND => NULL; -- release lock
            tdd: TEditDocument.TEditDocumentData = NARROW[ts.data];
            IF tdd # NIL THEN { OPEN tdd.tsInfo;
                IF tdd.tsInfo=NIL THEN RETURN; -- not a typescript
                WHILE inputLoc < Rope.Size[inputRope] OR iQp#oQp OR ~waitingInGetChar DO
                    WAIT untilTimesOutInALittleWhile;
                    ENDLOOP;
                };
            };


    <<Tip Table>>
        <<Exported to TEditPrivate>>
        typeScriptTIP: PUBLIC TIPUser.TIPTable; -- init below
        systemDir: ROPE ~ PFS.RopeFromPath[PFS.GetWDir[]]; -- the BootEssentials live here
        SystemTip: PROC [base: ROPE] RETURNS [ROPE] ~ {
            RETURN [Rope.Cat[systemDir, base, ".tip"]];
            };
        editTipNames: ROPE ~ Rope.Cat[SystemTip["EditTypeScript"], " ", SystemTip["Tioga"]];
        nonEditTipNames: ROPE ~ SystemTip["TypeScript"];
        ReloadTypeScriptTipTable: PUBLIC PROC = {
            tipNames: ROPE ~ 
                IF TEditProfile.editTypeScripts THEN editTipNames
                ELSE nonEditTipNames;
            newTIP: TIPUser.TIPTable ~ TEditPrivate.ReloadTable[oldTIP: typeScriptTIP, profileKey: "Tioga.TypescriptTip", default: tipNames];
            IF newTIP # NIL THEN tsClass.tipTable Ź typeScriptTIP Ź newTIP;
            };

        CaretAtEndOfTypescript: TIPUser.TIPPredicate --PROC RETURNS [BOOLEAN]-- = {
            tdd: TEditDocument.TEditDocumentData;
            ts: TS Ź TEditSelection.pSel.viewer;
            IF ts=NIL THEN RETURN [FALSE]; -- no primary selection
            tdd Ź NARROW[ts.data];
            IF tdd = NIL THEN RETURN [FALSE];
            IF tdd.tsInfo=NIL THEN RETURN [FALSE]; -- not a typescript
            RETURN [CaretAtEnd[TEditSelection.pSel]];
            };


    <<User Abort>>
        SetUserAbort: PROC [ts: TS] = {
            tdd: TEditDocument.TEditDocumentData Ź NARROW[ts.data, TEditDocument.TEditDocumentData];
            IF tdd # NIL THEN tdd.tsInfo.abort Ź TRUE;
            };


    <<TTY Class Defn>>
        typescriptMenu: Menus.Menu Ź Menus.CreateMenu[];

        splitDoc: ROPE ~ " Warning: Split typescript are known to misbehave.  Keep your bags packed.";
        Split: Menus.MenuProc = {TEditSplit.Split[NARROW[parent]]};
        Find: Menus.MenuProc = {viewer: ViewerClasses.Viewer ~ NARROW[parent];
            viewer.class.notify[viewer, LIST[SELECT mouseButton FROM
                red => IF shift THEN $FindNextCaseless ELSE $FindNext,
                yellow => IF shift THEN $FindAnyCaseless ELSE $FindAny,
                blue => IF shift THEN $FindPrevCaseless ELSE $FindPrev,
                ENDCASE => ERROR]]
            };

        tsClass: ViewerClasses.ViewerClass Ź -- just like Tioga's
            NEW[ViewerClasses.ViewerClassRec Ź ViewerOps.FetchViewerClass[$Text]­];

        <<except for a couple of differences>>
        tsClass.init Ź InitTypeScriptDocument;
        tsClass.notify Ź TypeScriptNotifyProc;
        tsClass.icon Ź typescript;
        ReloadTypeScriptTipTable[];
        ViewerOps.RegisterViewerClass [$Typescript, tsClass];
        TIPUser.RegisterTIPPredicate[$CaretAtEndOfTypescript, CaretAtEndOfTypescript];
        TEditInput.Register[$ApplyTypeScriptLook, ApplyTypeScriptLook];
        TEditInput.Register[$RemoveTypeScriptLook, RemoveTypeScriptLook];
        Menus.AppendMenuEntry[typescriptMenu, Menus.CreateEntry["Find", Find]];
        Menus.AppendMenuEntry[typescriptMenu, Menus.CreateEntry[name: "Split", proc: Split, documentation: splitDoc, guarded: TRUE]];

        TRUSTED {Process.SetTimeout[@untilTimesOutInALittleWhile, aLittleWhile]};
        TRUSTED {Process.SetTimeout[@bufferClear, aLittleWhile]; Process.EnableAborts[@bufferClear]};
        TRUSTED {Process.SetTimeout[@repaintDone, aLongerWhile]};
        END.