NSTTYAImpl.mesa
Copyright (C) 1984, 1986 by Xerox Corporation. All rights reserved.
Last Revised by Saund 9-May-85 13:44:48
Tim Diebert: January 6, 1987 5:09:24 pm PST
DIRECTORY
Ascii USING [CR, SP],
Basics USING [UnsafeBlock, HighByte, HighHalf, LowByte, LowHalf, RawBytes],
Convert USING [IntFromRope, RopeFromInt],
IO,
NSString USING [Character, String],
NSTranslate USING [GetFirstTable, XlateInfo],
NSTTY USING [GetChar, GetEditedString, PutChar, PutString],
Process USING [Abort, DisableTimeout, EnableAborts],
PrincOpsUtils USING [IsBound],
RefText USING [Append, ObtainScratch, ReleaseScratch, TrustTextAsRope],
Rope USING [ROPE, ToRefText],
Time USING [Packed, TimeZoneStandard],
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.dataFile ← NSTranslate.GetFirstTable[];
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 {
FormatProc: TYPE = PROCEDURE [r: nss.String, h: XFormat.Handle];
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];
};
Backing Files
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];
note that this does not work if there are alternate input streams --
};
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]};
IF radix = 8 THEN String.AppendChar[s, 'B]}; -- Done by Convert.RopeFromInt
[] ← 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};
extended output procedures
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]};
PutDate: PUBLIC PROCEDURE [
h: Handle, gmt: Time.Packed, format: TTY.DateFormat,
zone: Time.TimeZoneStandard] = {
CheckState[h]; Format.Date[OutString, gmt, format, zone, h]};
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]]};
PutLongNumber: PUBLIC PROCEDURE [
h: Handle, n: LONG UNSPECIFIED, format: TTY.NumberFormat] = {
CheckState[h]; Format.LongNumber[OutString, n, format, h]};
PutLongOctal: PUBLIC PROCEDURE [h: Handle, n: LONG UNSPECIFIED] = {
CheckState[h]; Format.LongOctal[OutString, n, h]};
PutNumber: PUBLIC PROCEDURE [
h: Handle, n: UNSPECIFIED, format: TTY.NumberFormat] = {
CheckState[h]; Format.Number[OutString, n, format, h]};
PutOctal: PUBLIC PROCEDURE [h: Handle, n: UNSPECIFIED] = {
CheckState[h]; Format.Octal[OutString, n, h]};
PutLongSubString, PutSubString: PUBLIC PROCEDURE [
h: Handle, ss: String.SubString] = {
CheckState[h]; Format.SubString[OutString, ss, h]};
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};
Basic Input Ouptut Routine
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]};
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.