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.


΄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
NSTranslate USING [GetFirstTable, XlateInfo],
Time USING [Packed, TimeZoneStandard],
h.dataFile _ NSTranslate.GetFirstTable[];
FormatProc: TYPE = PROCEDURE [r: nss.String, h: XFormat.Handle];
Backing Files
note that this does not work if there are alternate input streams --
Basic input
IF radix = 8 THEN String.AppendChar[s, 'B]};  -- Done by Convert.RopeFromInt
extended output procedures
PutDate: PUBLIC PROCEDURE [
h: Handle, gmt: Time.Packed, format: TTY.DateFormat,
zone: Time.TimeZoneStandard] = {
CheckState[h]; Format.Date[OutString, gmt, format, zone, h]};
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]};
Basic Input Ouptut Routine
Queue implementation
Κ}˜
codeš
œ™Kš
œE™EKš
œ*™*K™+—K˜š
Οk	˜	Kšœœœœ˜Kšœœ?˜KKšœœ˜)Kšœ
˜Kšœ	œ˜#Kšœœ™-Kšœ
œ0˜;Kšœœ'˜4Kšœœ˜Kšœœ:˜GKšœœœ˜Kšœœ™&Kšœ
œ!Οcœžœ˜cKšœ
œ]˜oKšœ
œ9˜HKšœ
œ9˜HKšœœ%˜2—K˜šΟn
œœ
œœ
˜+Kšœœ2œœ˜bKšœ
œ˜'K˜Kšœœ
œœ˜!Kšœœ
œ˜'—˜KšŸœœ
œ
œœ
œœœ
œœ
˜MKš
Ÿœœ
œ
œœ
˜"KšŸœœ
œœ
˜$KšŸœœ
œœ
˜'—˜Kšœœ
˜Kšœ	œ˜%Kšœœ˜+K˜8K˜HK˜B—˜K˜D—˜šŸœœ
œ
	œ
œœ
œœœœ˜xKšœœœœ˜Jšœœ
˜šœœ
œ˜Bšœ˜Kšœœ/˜M—Kšœœ˜!Kšœ
˜——K˜ K™)K˜K˜	K˜*K˜(Kšœœ˜)——˜šŸœœ
œ
œ œœœ˜UšŸ
œœ
	œ˜"Kšœ
œœ
˜šœ	˜Kšœ˜šœœ
œ
˜7Kšœœœœ
˜9——Kšœœ˜,—K˜;K˜#K˜Kšœ˜K˜Kšœ˜Kš
œ˜——˜š	Ÿœœ
	œœ
˜:šŸœœ
	œ˜%Kšœ
œœ
˜Kšœœ˜$K˜Kšœœ
	œ˜+—šŸœœ
	œ˜,Kšœœ	œ˜3—Kšœœ˜K˜Kš	œ	œ
œœ
œ
˜-Kšœœ
œ.˜Jš
˜K˜Kšœœ"œœ˜CK˜Kšœ
˜—K˜Kšœ
˜——˜šŸœœ
œ
œ
œœœ
˜cKšœ
œœ
˜Kš
œ˜šœœ
œœœ
˜:Kšœ˜K˜K˜Kšœ
˜—Kšœ
˜——˜šŸœœ
œ
œ
	œœ
œœ
˜dKšœ
œœ
˜Kšœœ7˜HKšœ
˜——˜šŸœœœ˜.Kšœœ	œ$™@Kšœœœœ
œ
œ˜S——˜šŸœœ
	œ#œ˜Bšœœ
œ˜%Kšœ	œœœ˜4K˜——šŸ	œœ
œ
œœ	œœ˜PKšœœ˜.Kšœ
œ˜Kšœœ
œ
œ˜.Kš
œ*˜*Kšœ
˜——˜šŸœŸœœ
œ
œ
œœœ˜_K˜K˜(Kšœœ˜3Kšœœ˜2K˜#K˜——K˜˜Kš
œ
™
KšŸ
œœ
œœ
˜#—˜šŸ
œœ
œ
	œ
œœ
œœ˜PKšœœ˜(——˜šŸœœ
œ
œ
	œœ
œœ˜XKšœœ
˜K˜K˜!K˜K˜+Kšœœ˜:Kšœœ˜9Kšœœ˜9Kšœœ˜8K˜#K˜——˜šŸœœ
œ
œ
œ	œœ˜IKšœ
œœ
˜K˜K˜Kš
œD™DKš
œ˜——˜šŸœœ
œ
œ
	œœ˜CKšœ
œœ
˜K˜K˜.Kš
œ˜——˜šŸ	œœ
œ
œ
œ
œœœ˜KKšœ
œœ
˜K˜šœ
œ#˜4Kšœœ
˜Kšœœ˜———˜šŸœœ
œ
œ
œœ˜<Kšœ
œœ
˜K˜C——˜š
Ÿœœ
œ
	œœ˜;K˜K˜)K˜#K˜——˜šŸœœ
œ
œ
	œ
œœœ˜VKšœ
œœ
˜K˜Kšœ˜Kš
žL˜LKš
œ˜——˜šŸœœ
œ
œ	œœ˜MKš
œ
œ
œ	œ	œ˜>——˜KšŸœ	œœ
œœœœ˜^—˜šŸœœ
œ
	œ	œœ˜DKšœ	œœ˜:——˜šŸ
œŸ	œŸœœ
œ
	œœ
œ˜SKšœœœœ˜/——˜Kš
œ™—˜šŸ
œœ
œ
œ
œœœ˜IKšœœ
œ˜(K˜K˜#Kš
œ8˜8Kš
œ˜Kšœ˜——˜šŸœœ
œ
œ
œœœ˜IKšœœ
œ˜(K˜K˜#Kš
œ8˜8Kš
œ˜Kšœ˜——˜šŸ
œœ
œ
œœ
œ	œœ
œœ
œœ˜—
Kšœœ
œ˜(Kšœœ
œ˜(K˜šœ
œ˜š
œœ
œ
œ
œ˜5Kšœ/˜3—Kš
œ8˜8Kš
œ!˜!Kšœœ;™L—K˜#Kš
œ8˜8Kš
œ˜Kš
œ˜Kšœ˜——˜šŸœœ
œ
œ
œœ
œœ˜TKšœœ
œ˜(K˜K˜#Kš
œ7˜7Kš
œ˜Kšœ˜——˜šŸ	œœ
œ
œœ	œœ
œœœ˜‰
Jšœ
œ
œœ
˜+Jšœœ
œ
˜Jš
œ8˜8Jšœœ
˜%Jšœ˜——˜šŸœœ
œ
œ
œœœ˜KJšœœ
œ
˜Jšœœ˜Jšœœ
˜%Jšœ˜——˜šŸœœ
œ
œœ
œœ˜<K˜3——˜šŸœœ
œ
œœ
œœ˜>KšœBœ˜G——˜šŸœœ
œ
œœ
œœ˜BKšœœ˜K˜K˜Kšœœ˜)Kšœ$œ˜DK˜——˜šŸ	œœ
œ
œœ
œ	œ	œœ
œœ˜~K˜5——˜šŸœœ
œœ
œ	œ	œœ
œœ	œœ
˜€
š	œœ
	œœ
œ˜NKš
œ
œœ
	œœ
˜;—Kšœœ˜Kš	œœ
œœ	œ˜IK˜Kšœ
˜——˜š
Ÿœ	œ	œœœ˜=Kšœ
œœ
œœ
œœ˜;——˜š
Ÿœ	œ	œœœ˜;Kš
œ
œœ
œœ˜+——˜šŸ
œœ
	œœ˜2Kšœ
œœœœ
œ
œ˜=——˜šŸœ	œœ˜4Kšœœ
œ
œ˜&——˜Kš
œ™—˜šŸ	œ	œœ
œ˜:K˜——˜šŸœŸ	œœ
œ
œœœ˜JKšœœ
œ˜)K˜Kš
œœ
œœœ
˜<K˜
K˜K˜——˜š
Ÿœœ
œ
œ*œ˜MKš
œ˜Kšœ"˜$——˜šŸœœ
	œ™Kšœ%œ™4K™ K™=——˜šŸœœ
œ
œœ
œœ˜>Kšœ1œ˜6——˜šŸ
œœ
œ
œœœ˜@K˜Kšœœ
˜$——˜šŸœœ
œ
œœ
œœ˜IK˜Kšœœ
˜%——˜šŸ
œœ
	œ™!Kšœœ
œ
œ™=K™;——˜š
Ÿœœ
	œœ
œ™CK™2——˜šŸ	œœ
	œ™Kšœœ
œ™8K™7——˜šŸœœ
	œœ™:K™.——˜šœŸœœ
	œ™2K™$K™3——˜šŸœœ
œ
œ
	œ
œœœ˜TKšœ
œœ
˜Kšœœ
˜'——˜šŸœœ
œ
œ
	œœœœœ˜mKšœ
œœ
˜Kš
œ3˜3——K˜˜Kš
œ™šŸœœ
œ
œ
	œ
œœœ
˜RKšœ
œœ
˜Kšœœœ
˜"K˜šœœ
˜šœœ
œ˜%Kšœœ$œœ˜:—Kšœœ
œ˜$Kšœ˜K˜K˜Kšœœ
˜Kšœ
˜—Kšœœœœ
˜PK˜Kšœ
˜——˜š
Ÿœœ
œ
	œœ˜5Kš
œ
œ
œœœ
˜4——˜šŸœœ
œ
œ
	œ
œœœ˜NKšœ
œœœ
˜A——K˜˜Kš
œ™—K˜˜Kšœœ
œ˜—˜Kšœœœ˜—˜Kšœœ
œœ˜+—˜Kšœœ
œ˜*—˜KšŸœœ
œ
˜—˜š	Ÿœ	œœœ˜@Kšœœ
œ
œ
˜šœœœ
˜1šœœ˜,Kšœ#˜'Kšœ˜—Kšœ
˜—Kš
˜Kšœ
˜——˜KšŸœ	œœœœœ
œœ˜Q—˜šŸœ	œ	˜šœ˜K˜K˜Kšœœ
œ
œ
œ
œ
˜4K˜Kšœ
˜—Kš
˜Kšœ
˜——˜š
Ÿœœ
	œœœ˜AKš
˜K˜Kšœœ
˜Kšœœ
œœ
œœœ˜?K˜
K˜šœ˜š
œž˜K˜Kšœœ
œ
œ
œœ
˜2K˜
Kš
˜—Kš

œœœœœ
˜Q—Kš
˜Kšœ
˜——˜šŸœœ
	œœœ˜GK˜Kšœœ
˜Kšœœ
œ
œ
œœœ˜>K˜K˜šœ˜š
œž˜K˜Kšœœ
œœ
œœ
˜3K˜Kš
˜—Kš

œœ	œœœ
˜P—Kš
˜Kšœ
˜——˜šŸœœ
	œœ˜8Kš
˜K˜Kšœœ
˜Kšœœ
œ
œ
˜K˜šœœ
œ˜š

˜
Kšœ
œ)˜6K˜Kšœœ
œœ˜1K˜K˜Kš
˜—Kšœœœœ
˜>—K˜K˜Kš
˜Kšœ
˜——˜šŸ	œ	œ$˜>šœœ
œ2˜AKš	œœ
œ
œœ
˜=Kšœœ
˜—Kšœ
˜——˜šŸœ	œœœ˜6Kšœ˜šœ
˜šœ
œœœ˜@K˜
————K˜K˜˜Kšœ˜—Kšœ˜K˜:KšœTœ
˜_šœ1	˜:Kšœ"œœœ|˜³
—K˜yK˜Dšœ$œœœp˜€
Kšœ œ	œ6˜fK˜`K˜—K˜—…—>[9