<> <> <> <> DIRECTORY Ascii USING [CR, SP], Basics USING [UnsafeBlock, HighByte, HighHalf, LowByte, LowHalf, RawBytes], Convert USING [IntFromRope, RopeFromInt], IO, NSString USING [Character, String], <> NSTTY USING [GetChar, GetEditedString, PutChar, PutString], Process USING [Abort, DisableTimeout, EnableAborts], PrincOpsUtils USING [IsBound], RefText USING [Append, ObtainScratch, ReleaseScratch, TrustTextAsRope], Rope USING [ROPE, ToRefText], <> TTY USING [CharStatus, CreateTTYInstance, -- DateFormat, -- EchoClass, Handle --, NumberFormat-- ], TTYConstants USING [aborted, blinkDisplay, deleteBackingFile, normal, notAborted, removeChars, setBackingSize], TTYExtras USING [AltHandle, AltObject, Handle, Object, QElement, QHead], TTYStream USING [SendAttention, SetSST, SubSequenceType, WaitAttention], XFormat USING [Error, FormatProc, Handle, Object]; NSTTYAImpl: MONITOR LOCKS h USING h: Handle IMPORTS Basics, Convert, IO, PrincOpsUtils, Process, RefText, Rope, XFormat, NSTTY, TTY, TTYStream EXPORTS TTY, XFormat, TTYExtras = BEGIN Handle: PUBLIC TYPE = REF Object; Object: PUBLIC TYPE = TTYExtras.Object; LineOverflow: PUBLIC SAFE SIGNAL [s: REF TEXT] RETURNS [ns: REF TEXT] = CODE; Rubout: PUBLIC SAFE SIGNAL = CODE; OutOfInstances: PUBLIC ERROR = CODE; NoDefaultInstance: PUBLIC ERROR = CODE; list: Handle _ NIL; aborted: BYTE = TTYConstants.aborted; notAborted: BYTE = TTYConstants.notAborted; normal: TTYStream.SubSequenceType = TTYConstants.normal; setBackingSize: TTYStream.SubSequenceType = TTYConstants.setBackingSize; removeChars: TTYStream.SubSequenceType = TTYConstants.removeChars; blinkDisplay: TTYStream.SubSequenceType = TTYConstants.blinkDisplay; Create: PUBLIC SAFE PROCEDURE [name: Rope.ROPE, backingStream, ttyImpl: IO.STREAM _ NIL] RETURNS [h: Handle] = TRUSTED { h _ NEW[TTYExtras.Object _ [stream: NIL, backingStream: NIL, next: list]]; IF ttyImpl = NIL THEN SELECT PrincOpsUtils.IsBound[LOOPHOLE[TTY.CreateTTYInstance]] FROM TRUE => [ttyImpl, backingStream] _ TTY.CreateTTYInstance[name, backingStream, h.tty]; FALSE => ERROR NoDefaultInstance; ENDCASE; h.backingStream _ backingStream; <> h.stream _ ttyImpl; list _ h; Process.DisableTimeout[@h.inputCondition]; Process.EnableAborts[@h.inputCondition]; h.inputProcess _ FORK ListenForInput[h]}; Destroy: PUBLIC SAFE PROC [h: Handle, deleteBackingFile: BOOLEAN _ FALSE] = TRUSTED { P: ENTRY PROCEDURE [h: Handle] = { ENABLE UNWIND => NULL; IF list = h THEN list _ h.next ELSE FOR l: Handle _ list, l.next UNTIL l.next = NIL DO IF l.next = h THEN {l.next _ l.next.next; EXIT}; ENDLOOP; IF ~IsEmpty[h.buffer] THEN Empty[h.buffer]}; TTYStream.SetSST[h.stream, TTYConstants.deleteBackingFile]; TTYStream.SetSST[h.stream, normal]; Process.Abort[h.inputProcess]; JOIN h.inputProcess; P[h]; IO.Close[h.stream]; }; ListenForInput: SAFE PROCEDURE [h: Handle] = TRUSTED BEGIN DoIt: ENTRY PROCEDURE [h: Handle] = { ENABLE UNWIND => NULL; wakeUp: BOOLEAN = IsEmpty[h.buffer]; BlockToQR[block, h.buffer]; IF wakeUp THEN BROADCAST h.inputCondition}; AbortClient: ENTRY PROCEDURE [h: Handle] = { h.inputAborted _ TRUE; BROADCAST h.inputCondition}; blockSize: CARDINAL = 20; block: Basics.UnsafeBlock; storage: PACKED ARRAY [0..blockSize) OF BYTE; block _ [base: LOOPHOLE[LONG[@storage]], startIndex: 0, count: blockSize]; DO block.count _ blockSize; block.count _ IO.UnsafeGetBlock[h.stream, block ! ABORTED => EXIT]; DoIt[h]; ENDLOOP; AbortClient[h]; END; PopAlternateInputStreams: PUBLIC ENTRY SAFE PROC [h: Handle, howMany: CARDINAL _ 1] = TRUSTED BEGIN ENABLE UNWIND => NULL; temp: TTYExtras.AltHandle; FOR i: CARDINAL IN [0..howMany) WHILE h.altStream # NIL DO IO.Close[h.altStream.s]; temp _ h.altStream; h.altStream _ h.altStream.next; ENDLOOP; END; PushAlternateInputStream: PUBLIC ENTRY SAFE PROCEDURE [h: Handle, stream: IO.STREAM] = TRUSTED BEGIN ENABLE UNWIND => NULL; h.altStream _ NEW[TTYExtras.AltObject _ [s: stream, next: h.altStream]]; END; TTYProc: PUBLIC XFormat.FormatProc = TRUSTED { <> ttyH: Handle = LOOPHOLE[h.stream]; IF h.stream = NIL THEN RETURN; Filter[r, ttyH]}; Filter: SAFE PROCEDURE [r: NSString.String, h: Handle] = TRUSTED { FOR n: CARDINAL IN [0 .. r.length) DO NSTTY.PutChar[LOOPHOLE[h], LOOPHOLE[r[n]]] ENDLOOP}; TTYObject: PUBLIC SAFE PROC [h: TTY.Handle] RETURNS [XFormat.Handle] = TRUSTED { handle: XFormat.Handle _ NEW [XFormat.Object]; hh: Handle _ LOOPHOLE[h]; IF hh = NIL THEN ERROR XFormat.Error[nilData]; handle.proc _ TTYProc; handle.stream _ hh; RETURN[handle]}; RemoveCharacter, RemoveCharacters: PUBLIC ENTRY SAFE PROC [h: Handle, n: CARDINAL] = TRUSTED { InternalCheckState[h]; TTYStream.SetSST[h.stream, removeChars]; IO.PutChar[h.stream, LOOPHOLE[Basics.HighByte[n]]]; IO.PutChar[h.stream, LOOPHOLE[Basics.LowByte[n]]]; TTYStream.SetSST[h.stream, normal]; }; <> NoBackingFile: PUBLIC ERROR = CODE; BackingStream: PUBLIC SAFE PROCEDURE [h: Handle] RETURNS [IO.STREAM] = TRUSTED { CheckState[h]; RETURN[h.backingStream]}; SetBackingSize: PUBLIC ENTRY SAFE PROCEDURE [h: Handle, size: LONG CARDINAL] = TRUSTED { lowHalf, highHalf: CARDINAL; InternalCheckState[h]; highHalf _ Basics.HighHalf[size]; lowHalf _ Basics.LowHalf[size]; TTYStream.SetSST[h.stream, setBackingSize]; IO.PutChar[h.stream, LOOPHOLE[Basics.HighByte[highHalf]]]; IO.PutChar[h.stream, LOOPHOLE[Basics.LowByte[highHalf]]]; IO.PutChar[h.stream, LOOPHOLE[Basics.HighByte[lowHalf]]]; IO.PutChar[h.stream, LOOPHOLE[Basics.LowByte[lowHalf]]]; TTYStream.SetSST[h.stream, normal]; }; PutBackChar: PUBLIC ENTRY SAFE PROC [h: Handle, c: CHARACTER] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; PutR[h.buffer, c]; <> }; ResetUserAbort: PUBLIC ENTRY SAFE PROCEDURE [h: Handle] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; TTYStream.SendAttention[h.stream, notAborted]; }; UserAbort: PUBLIC ENTRY SAFE PROC [h: Handle] RETURNS [BOOLEAN] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; RETURN[SELECT TTYStream.WaitAttention[h.stream] FROM aborted => TRUE, ENDCASE => FALSE]}; SetUserAbort: PUBLIC ENTRY SAFE PROC [h: Handle] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; TTYStream.SendAttention[h.stream, aborted]}; BlinkDisplay: PUBLIC SAFE PROCEDURE [h: Handle] = TRUSTED { CheckState[h]; TTYStream.SetSST[h.stream, blinkDisplay]; TTYStream.SetSST[h.stream, normal]; }; CharsAvailable: PUBLIC ENTRY SAFE PROCEDURE [h: Handle] RETURNS [CARDINAL] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; RETURN[Count[h.buffer]]; -- note that this count is incorrect if there are alternate input streams -- }; GetChar: PUBLIC SAFE PROCEDURE [h: Handle] RETURNS [c: CHARACTER] = TRUSTED { RETURN[LOOPHOLE[NSTTY.GetChar[LOOPHOLE[h]].code, CHARACTER]]}; STR: PROCEDURE [mesaString: REF TEXT] RETURNS [NSString.String] = INLINE {RETURN[mesaString]}; PutChar: PUBLIC SAFE PROCEDURE [h: Handle, c: CHARACTER] = TRUSTED { NSTTY.PutChar[LOOPHOLE[h], NSString.Character[0, c.ORD]]}; PutLongString, PutString, PutText: PUBLIC SAFE PROCEDURE [h: Handle, s: REF TEXT] = TRUSTED {NSTTY.PutString[LOOPHOLE[h], STR[s]]}; <> GetDecimal: PUBLIC SAFE PROC [h: Handle] RETURNS [i: INTEGER] = TRUSTED { s: REF TEXT _ RefText.ObtainScratch[10]; CheckState[h]; [] _ GetEditedString[h, s, IsAtom]; i _ Convert.IntFromRope[RefText.TrustTextAsRope[s], 10]; RefText.ReleaseScratch[s]; RETURN[i]}; GetLongDecimal: PUBLIC SAFE PROC [h: Handle] RETURNS [n: INT] = TRUSTED { s: REF TEXT _ RefText.ObtainScratch[32]; CheckState[h]; [] _ GetEditedString[h, s, IsAtom]; n _ Convert.IntFromRope[RefText.TrustTextAsRope[s], 10]; RefText.ReleaseScratch[s]; RETURN[n]}; GetLongNumber: PUBLIC SAFE PROC [h: Handle, default: LONG UNSPECIFIED, radix: CARDINAL, showDefault: BOOLEAN] RETURNS [n: LONG UNSPECIFIED] = TRUSTED { s: REF TEXT _ RefText.ObtainScratch[32]; r: REF TEXT _ RefText.ObtainScratch[32]; CheckState[h]; IF showDefault THEN { IF radix = 10 AND LOOPHOLE[default, LONG INTEGER] < 0 THEN {s[0] _ '-; s.length _ 1; default _ -default}; r _ Rope.ToRefText[Convert.RopeFromInt[default, radix]]; s _ RefText.Append[s, r, radix]}; <> [] _ GetEditedString[h, s, IsAtom]; n _ Convert.IntFromRope[RefText.TrustTextAsRope[s], 10]; RefText.ReleaseScratch[s]; RefText.ReleaseScratch[r]; RETURN[n]}; GetLongOctal: PUBLIC SAFE PROC [h: Handle] RETURNS [n: LONG UNSPECIFIED] = TRUSTED { s: REF TEXT _ RefText.ObtainScratch[32]; CheckState[h]; [] _ GetEditedString[h, s, IsAtom]; n _ Convert.IntFromRope[RefText.TrustTextAsRope[s], 8]; RefText.ReleaseScratch[s]; RETURN[n]}; GetNumber: PUBLIC SAFE PROC [h: Handle, default: UNSPECIFIED, radix: CARDINAL, showDefault: BOOLEAN] RETURNS [n: UNSPECIFIED] = TRUSTED { sDefault: LONG UNSPECIFIED _ LONG[default]; result: LONG UNSPECIFIED; result _ GetLongNumber[h, sDefault, radix, showDefault]; n _ Basics.LowHalf[LOOPHOLE[result]]; RETURN[n]}; GetOctal: PUBLIC SAFE PROC [h: Handle] RETURNS [n: UNSPECIFIED] = TRUSTED { result: LONG UNSPECIFIED; result _ GetLongOctal[h]; n _ Basics.LowHalf[LOOPHOLE[result]]; RETURN[n]}; GetID: PUBLIC SAFE PROC [h: Handle, s: REF TEXT] = TRUSTED { CheckState[h]; [] _ GetEditedString[h, s, IsAtom]}; GetLine: PUBLIC SAFE PROC [h: Handle, s: REF TEXT] = TRUSTED { CheckState[h]; [] _ GetEditedString[h, s, IsCR]; PutChar[h, Ascii.CR]}; GetPassword: PUBLIC SAFE PROC [h: Handle, s: REF TEXT] = TRUSTED { old: TTY.EchoClass; CheckState[h]; old _ SetEcho[h, stars]; IF old = none THEN [] _ SetEcho[h, none]; [] _ GetEditedString[h, s, IsAtom ! UNWIND => [] _ SetEcho[h, old]]; [] _ SetEcho[h, old]}; GetString: PUBLIC SAFE PROC [h: Handle, s: REF TEXT, t: PROCEDURE [c: CHARACTER] RETURNS [status: TTY.CharStatus]] = TRUSTED { CheckState[h]; PutChar[h, GetEditedString[h, s, t]]}; GetEditedString: PUBLIC SAFE PROCEDURE [h: Handle, s: REF TEXT, t: PROCEDURE [c: CHARACTER] RETURNS [status: TTY.CharStatus]] RETURNS [c: CHARACTER] = TRUSTED BEGIN tt: SAFE PROCEDURE [nc: NSString.Character] RETURNS [status: TTY.CharStatus] = TRUSTED BEGIN status _ t[LOOPHOLE[nc.code, CHARACTER]] END; ss: NSString.String _ STR[s]; c _ LOOPHOLE[NSTTY.GetEditedString[LOOPHOLE[h], ss, tt].code, CHARACTER]; s.length _ ss.length; END; IsAtom: PROCEDURE [c: CHARACTER] RETURNS [TTY.CharStatus] = { RETURN[IF c = Ascii.SP OR c = Ascii.CR THEN stop ELSE ok]}; IsCR: PROCEDURE [c: CHARACTER] RETURNS [TTY.CharStatus] = { RETURN[IF c = Ascii.CR THEN stop ELSE ok]}; CheckState: ENTRY PROCEDURE [h: Handle] = INLINE { ENABLE UNWIND => NULL; IF h.inputAborted THEN ERROR ABORTED}; InternalCheckState: PROCEDURE [h: Handle] = INLINE { IF h.inputAborted THEN ERROR ABORTED}; <> OutString: PROCEDURE [s: REF TEXT, clientData: Handle] = { PutString[clientData, s]}; PutBlank, PutBlanks: PUBLIC SAFE PROC [h: Handle, n: CARDINAL] = TRUSTED { s: REF TEXT _ RefText.ObtainScratch[n*2]; CheckState[h]; FOR i: CARDINAL IN [0 .. s.maxLength) DO s[i] _ ' ; ENDLOOP; s.length _ n; OutString[s, h]; RefText.ReleaseScratch[s]}; PutBlock: PUBLIC SAFE PROC [h: Handle, block: Basics.UnsafeBlock] = TRUSTED { CheckState[h]; IO.UnsafePutBlock[h.stream, block]}; <> <> <> <> PutLine: PUBLIC SAFE PROC [h: Handle, s: REF TEXT] = TRUSTED { CheckState[h]; PutString[h, s]; PutChar[h, Ascii.CR]}; PutDecimal: PUBLIC SAFE PROC [h: Handle, n: INTEGER] = TRUSTED { CheckState[h]; IO.PutF[h.stream, "%g", IO.int[n]]}; PutLongDecimal: PUBLIC SAFE PROC [h: Handle, n: LONG INTEGER] = TRUSTED { CheckState[h]; IO.PutF1[h.stream, "%g", IO.int[n]]}; <> <> <> <> <> <> <> <> <> <> <> <> <> GetEcho: PUBLIC ENTRY SAFE PROCEDURE [h: Handle] RETURNS [TTY.EchoClass] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; RETURN[h.echo]}; SetEcho: PUBLIC ENTRY SAFE PROCEDURE [h: Handle, new: TTY.EchoClass] RETURNS [old: TTY.EchoClass] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; old _ h.echo; h.echo _ new}; <> GetByte: PUBLIC ENTRY SAFE PROCEDURE [h: Handle] RETURNS [c: BYTE] = TRUSTED BEGIN ENABLE UNWIND => NULL; advanceAltStream: BOOLEAN _ FALSE; temp: TTYExtras.AltHandle; WHILE h.altStream # NIL DO c _ LOOPHOLE[IO.GetChar[h.altStream.s ! IO.EndOfStream => {advanceAltStream _ TRUE; CONTINUE}]]; IF ~advanceAltStream THEN RETURN[c]; IO.Close[h.altStream.s]; temp _ h.altStream; h.altStream _ h.altStream.next; advanceAltStream _ FALSE; ENDLOOP; WHILE IsEmpty[h.buffer] DO InternalCheckState[h]; WAIT h.inputCondition ENDLOOP; c _ GetF[h.buffer] END; PutByte: PUBLIC SAFE PROCEDURE [h: Handle, c: BYTE] = TRUSTED BEGIN IO.PutChar[h.stream, LOOPHOLE[c]] END; NewLine: PUBLIC ENTRY SAFE PROCEDURE [h: Handle] RETURNS [BOOLEAN] = TRUSTED { ENABLE UNWIND => NULL; InternalCheckState[h]; RETURN[h.col = 0]}; <> BYTE: PRIVATE TYPE = [0..255]; Q: TYPE = REF TTYExtras.QHead; pQE: PRIVATE TYPE = REF TTYExtras.QElement; defaultElementSize: PRIVATE CARDINAL = 20; EmptyQ: SIGNAL [q: Q] = CODE; Count: PROCEDURE [q: Q] RETURNS [elements: CARDINAL _ 0] = BEGIN IF q = NIL THEN RETURN; FOR qp: pQE _ q.front, qp.flink UNTIL qp = NIL DO elements _ elements + (IF qp.front > qp.rear THEN qp.maxLen - qp.front + qp.rear + 1 ELSE qp.rear - qp.front + 1); ENDLOOP; RETURN END; IsEmpty: PROCEDURE [q: Q] RETURNS [BOOLEAN] = {RETURN[q = NIL OR q.front = NIL]}; Empty: PROCEDURE [q: Q] = BEGIN UNTIL IsEmpty[q] DO qf: pQE _ q.front; nqf: pQE = qf.flink; IF nqf = NIL THEN q.rear _ NIL ELSE nqf.rlink _ NIL; q.front _ nqf; ENDLOOP; RETURN END; GetF: PUBLIC PROCEDURE [q: Q] RETURNS [i: UNSPECIFIED [0..255]] = BEGIN qf: pQE; qff: CARDINAL; IF q = NIL OR q.front = NIL THEN {SIGNAL EmptyQ[q]; RETURN[0]}; qf _ q.front; i _ qf[qff _ qf.front]; IF qf.front = qf.rear THEN BEGIN -- element empty nf: pQE = qf.flink; IF nf = NIL THEN q.rear _ NIL ELSE nf.rlink _ NIL; q.front _ nf; END ELSE BEGIN qff _ IF qff = qf.maxLen - 1 THEN 0 ELSE qff + 1; qf.front _ qff; END; RETURN END; GetR: PUBLIC PROCEDURE [q: Q] RETURNS [i: UNSPECIFIED [0..255]] = BEGIN qr: pQE; qrr: CARDINAL; IF q = NIL OR q.rear = NIL THEN {SIGNAL EmptyQ[q]; RETURN[0]}; qr _ q.rear; i _ qr[qrr _ qr.rear]; IF qr.rear = qr.front THEN BEGIN -- element empty nr: pQE = qr.rlink; IF nr = NIL THEN q.front _ NIL ELSE nr.flink _ NIL; q.rear _ nr; END ELSE BEGIN qrr _ IF qrr = 0 THEN qr.maxLen - 1 ELSE qrr - 1; qr.rear _ qrr; END; RETURN END; PutR: PUBLIC PROCEDURE [q: Q, i: UNSPECIFIED [0..255]] = BEGIN qr: pQE; qrr: CARDINAL; IF q = NIL THEN RETURN; qr _ q.rear; IF qr = NIL OR FullElement[qr] THEN BEGIN nr: pQE _ NEW[TTYExtras.QElement[defaultElementSize]]; nr.rlink _ qr; IF qr = NIL THEN q.front _ nr ELSE qr.flink _ nr; q.rear _ qr _ nr; qrr _ 0; END ELSE qrr _ IF qr.rear = qr.maxLen - 1 THEN 0 ELSE qr.rear + 1; qr[qrr] _ i; qr.rear _ qrr; RETURN END; BlockToQR: PROCEDURE [block: Basics.UnsafeBlock, q: Q] = BEGIN FOR i: INT IN [block.startIndex..block.startIndex+block.count) DO base: LONG POINTER TO Basics.RawBytes _ LOOPHOLE[block.base]; PutR[q, base[i]] ENDLOOP; END; FullElement: PROCEDURE [qe: pQE] RETURNS [BOOLEAN] = { OPEN qe; RETURN[ (IF rear < front THEN maxLen + rear - front ELSE rear - front) = maxLen - 1]}; END.... LOG [Time - Person - Action] 17-Feb-84 13:35:26 - Saund - cloned from the mesa TTYImpl. 30-Mar-84 14:40:24 - Saund - Made SetBackingSize, RemoveCharacter, RemoveCharacters ENTRY PROCS 24-Apr-84 15:14:22 - Alfvin - Remove unnecessary LOOPHOLES 1-May-84 18:23:57 - KNguyen - Fix AR#6265: NSTTY: BREAK key does not have the correct behavior; by changing proc. ResetUserAbort. (This should be fixed by Pilot in TTYLearSiegler) 16-May-84 0:02:53 - Alfvin - Reimplement NewLine in terms of h.col, because h.newline was not being maintained properly. 12-Jun-84 14:33:19 - Saund - Exports NSTTYExtras.NewSetPagination[]; 26-Jun-84 11:36:037 - KNguyen - Fix AR#8730 TTY: TTY.GetEditedString(NSTTYAImpl.GetEditedString) has bug; this is because in GetEditedString, s.length was never set 3-Aug-84 10:06:45 - Saund - Fix AR: 10321 NSTTY: Non-CharSet0 chars are displayed as character set 0. 9-May-85 13:44:14 - McManis - Removed export of NSTTYExtras.NewSetPagination. Now in NSTTYBImpl.