-- MockingbirdTTY.mesa
-- Derived from MockingbirdTTY.mesa
-- last edited by Forrest January 6, 1981 7:28 PM
-- last edited by Levin on 14-Apr-82 18:02:39
-- last edited by McGregor on April 22, 1982 4:23 pm
-- last gutted by Maxwell on May 20, 1982 10:02 am
-- This module also implements non-basic tty features (see end of code).
-- if these are not needed, String and Format may be left unbound
DIRECTORY
Ascii USING [
BS, ControlA, ControlR, ControlQ, ControlV, ControlW, ControlX, CR, DEL,
ESC, FF, SP, TAB],
BitBlt USING [AlignedBBTable, BBptr, BBTableSpace, BITBLT],
Environment USING [BitAddress],
Format USING [
Date, Decimal, LongDecimal, LongNumber, LongOctal, LongSubStringItem,
Number, Octal, SubString],
Inline USING [BITAND],
Process USING [Detach, SetPriority],
Runtime USING [GetTableBase],
SpecialSpace USING [
MakeGlobalFrameResident, --MakeGlobalFrameSwappable,--
MakeProcedureResident],
String USING [
AppendChar, AppendLongNumber, AppendNumber,
StringToLongNumber, StringToNumber, SubString],
TerminalMultiplex USING [InputController, RegisterInputController, SelectTerminal],
Time USING [Packed],
TTY USING [DateFormat, Handle, LongSubString, NumberFormat],
UserTerminal USING [
Coordinate, cursor, GetBitBltTable, keyboard, mouse, screenHeight,
screenWidth, SetMousePosition, SetState, SetBackground,
WaitForScanLine];
MockingbirdTTY: MONITOR
LOCKS m USING m: POINTER TO MONITORLOCK
IMPORTS
BitBlt, Format, Inline, Process, Runtime, SpecialSpace,
String, TerminalMultiplex, UserTerminal
EXPORTS TTY =
BEGIN OPEN Ascii, BitBlt;
screenLock: MONITORLOCK;
keyboardLock: MONITORLOCK;
shuttingDown: BOOLEAN ← FALSE;
shutDown: CONDITION ← [timeout: 0];
startingUp: BOOLEAN ← FALSE;
startUp: CONDITION ← [timeout: 0];
noTrack: CARDINAL ← 0;
Initialize: PROCEDURE = {
IF ~TerminalMultiplex.SelectTerminal[alternate] THEN ERROR;
TerminalMultiplex.RegisterInputController[InputController];
InputController[enable]};
InputController: TerminalMultiplex.InputController = {
SELECT action FROM
enable => {IF useCount = 0 THEN TurnOnTerminal[]; StartTerminal[]};
disable => TurnOffTerminal[];
ENDCASE};
TurnOnTerminal: PROCEDURE = {
TurnOnInternal: ENTRY PROC [m: POINTER TO MONITORLOCK] = {
IF ~font.newStyle OR font.indexed OR font.min NOT IN [0C..177C]
OR font.max+1 NOT IN [0C..177C] THEN ERROR;
WHILE shuttingDown DO WAIT shutDown ENDLOOP;
SpecialSpace.MakeProcedureResident[ProcessKeyboard];
SpecialSpace.MakeGlobalFrameResident[MockingbirdTTY];
CDT ← FALSE;
echo ← TRUE;
in ← out ← 0;
[] ← UserTerminal.SetState[on];
[] ← UserTerminal.SetBackground[white];
ClearScreen[]; -- to force init of bbPtr (since may have changed)
Process.Detach[FORK ProcessKeyboard]};
TurnOnInternal[@keyboardLock]};
StartTerminal: PROCEDURE = {
StartInternal: ENTRY PROC [m: POINTER TO MONITORLOCK] = {
startingUp ← TRUE; BROADCAST startUp};
StartInternal[@keyboardLock]};
TurnOffTerminal: PROCEDURE = {
TurnOffInternal: ENTRY PROC [m: POINTER TO MONITORLOCK] = {
shuttingDown ← TRUE;
WHILE shuttingDown DO WAIT shutDown ENDLOOP};
-- Pilot doesn't do this right: SpecialSpace.MakeGlobalFrameSwappable[MockingbirdTTY];
-- SpecialSpace.MakeProcedureSwappable[ProcessKeyboard];
-- [] ← UserTerminal.SetState[disconnected]};
TurnOffInternal[@keyboardLock]};
EnableCursorTracking: PUBLIC PROCEDURE = {
EnableInternal: ENTRY PROC [m: POINTER TO MONITORLOCK] = {
IF (noTrack ← noTrack - 1) = 0 THEN doBlink ← TRUE};
EnableInternal[@keyboardLock]};
DisableCursorTracking: PUBLIC PROCEDURE = {
DisableInternal: ENTRY PROC [m: POINTER TO MONITORLOCK] = {
IF (noTrack ← noTrack + 1) ~= 0 THEN doBlink ← FALSE};
DisableInternal[@keyboardLock]};
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- FONT Definitions and variables
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
font: LONG POINTER TO MACHINE DEPENDENT RECORD [
newStyle(0:0..0): BOOLEAN,
indexed(0:1..1): BOOLEAN,
fixed(0:2..2): BOOLEAN,
kerned(0:3..3): BOOLEAN,
pad(0:4..15): [0..7777B],
min(1): CHARACTER, -- limits of chars in font
max(2): CHARACTER, -- limits of chars in font
maxwidth(3): CARDINAL,
length(4): CARDINAL,
ascent(5): CARDINAL,
descent(6): CARDINAL,
xoffset(7): CARDINAL,
raster(8): CARDINAL,
chars(9:0..63): SELECT OVERLAID * FROM
hasBoundingBox => [
boundingBox(9:0..63): RECORD [FontBBox, FontBBoy, FontBBdx, FontBBDy: INTEGER],
BBBitmap(13): ARRAY [0..0) OF WORD],
noBoundingBox => [bitmap(9): ARRAY [0..0) OF WORD],
ENDCASE] = GetFont[];
bitmap: LONG POINTER = IF font.kerned THEN @font.BBBitmap ELSE @font.bitmap;
xInSegment: LONG POINTER TO ARRAY CHARACTER [0C..0C) OF CARDINAL =
bitmap + font.raster*FontHeight[] - (font.min-0C);
height: INTEGER[0..LAST[INTEGER]] = FontHeight[];
CharWidth: PROC [char: CHARACTER] RETURNS [[0..LAST[INTEGER]]] =
INLINE BEGIN
IF char NOT IN [font.min..font.max] THEN char ← font.max+1;
RETURN[xInSegment[char+1] - xInSegment[char]]
END;
FontHeight: PROC RETURNS [[0..LAST[INTEGER]]] = INLINE {RETURN[font.ascent+font.descent]};
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Keyboard Definitions and Constants
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
downUp: TYPE = {down, up};
keycount: CARDINAL = 80; -- must be 0 mod 16
Keyarray: TYPE = MACHINE DEPENDENT RECORD [SELECT OVERLAID * FROM
b => [bits: PACKED ARRAY [0..keycount) OF downUp],
wds => [wds: ARRAY [0..keycount/16) OF WORD],
ENDCASE];
KeyItem: TYPE = RECORD [
Letter: BOOLEAN, ShiftCode: CHARACTER [0C..177C], NormalCode: CHARACTER [0C..377C]];
-- Keyboard Info
ctrl: CARDINAL = 52;
leftShift: CARDINAL = 57;
shiftLock: CARDINAL = 72;
rightShift: CARDINAL = 76;
spare3: CARDINAL = 77;
KeyTable: ARRAY [16..keycount) OF KeyItem = [
-- Index [0..15] mouse, etc
-- Index [16..31]
[FALSE, 45C, 65C], -- %,5
[FALSE, 44C, 64C], -- $,4
[FALSE, 176C, 66C], -- ~,6
[TRUE, 105C, 145C], -- E
[FALSE, 46C, 67C], -- &,7
[TRUE, 104C, 144C], -- D
[TRUE, 125C, 165C], -- U
[TRUE, 126C, 166C], -- V
[FALSE, 51C, 60C], -- ),0
[TRUE, 113C, 153C], -- K
[FALSE, 30C, 55C], -- `,-
[TRUE, 120C, 160C], -- P
[FALSE, 77C, 57C], -- ?,/
[FALSE, 174C, 134C], -- |,\
[FALSE, 12C, 12C], -- LF
[FALSE, 10C, 10C], -- BS
-- Index [32..47]
[FALSE, 43C, 63C], -- #,3
[FALSE, 100C, 62C], -- @,2
[TRUE, 127C, 167C], -- W
[TRUE, 121C, 161C], -- Q
[TRUE, 123C, 163C], -- S
[TRUE, 101C, 141C], -- A
[FALSE, 50C, 71C], -- (,9
[TRUE, 111C, 151C], -- I
[TRUE, 130C, 170C], -- X
[TRUE, 117C, 157C], -- O
[TRUE, 114C, 154C], -- L
[FALSE, 74C, 54C], -- <,,
[FALSE, 42C, 47C], -- ",'
[FALSE, 175C, 135C], --},]
[FALSE, 0C, 0C], -- SPARE2
[FALSE, 0C, 0C], -- SPARE1
-- Index [48..63]
[FALSE, 41C, 61C], -- !,1
[FALSE, 33C, 33C], -- ESCAPE
[FALSE, 11C, 11C], -- TAB
[TRUE, 106C, 146C], -- F
[FALSE, 0C, 0C], -- CONTROL
[TRUE, 103C, 143C], -- C
[TRUE, 112C, 152C], -- J
[TRUE, 102C, 142C], -- B
[TRUE, 132C, 172C], -- Z
[FALSE, 0C, 0C], -- SHIFT
[FALSE, 76C, 56C], -- >,.
[FALSE, 72C, 73C], -- :,;
[FALSE, 15C, 15C], -- CR
[FALSE, 136C, 137C], -- ↑,←
[FALSE, 177C, 177C], -- DEL
[FALSE, 0C, 0C], -- NOT USED (FL3)
-- Index [64..79]
[TRUE, 122C, 162C], -- R
[TRUE, 124C, 164C], -- T
[TRUE, 107C, 147C], -- G
[TRUE, 131C, 171C], -- Y
[TRUE, 110C, 150C], -- H
[FALSE, 52C, 70C], -- *,8
[TRUE, 116C, 156C], -- N
[TRUE, 115C, 155C], -- M
[FALSE, 0C, 0C], -- LOCK
[FALSE, 40C, 40C], -- SPACE
[FALSE, 173C, 133C], -- {,[
[FALSE, 53C, 75C], -- +,=
[FALSE, 0C, 0C], -- Shift
[FALSE, 0C, 0C], -- Spare3
[FALSE, 0C, 0C], -- not user (FR4)
[FALSE, 0C, 0C]]; -- not user (FR5)
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Simple TTY Procedures
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
useCount: CARDINAL ← 0;
Create: PUBLIC PROC [STRING] RETURNS [TTY.Handle] =
BEGIN
useCount ← useCount + 1;
RETURN[LOOPHOLE[100000B]]
END;
Destroy: PUBLIC PROC [TTY.Handle] =
BEGIN
useCount ← useCount - 1;
END;
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Keyboard Implementation
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CDT: BOOLEAN;
charactersAvailable: CONDITION;
echo: BOOLEAN;
-- EXTERNAL PROCEDURES
CtrlChar: PROC [c: CHARACTER] RETURNS [CHARACTER] = INLINE {RETURN[LOOPHOLE[Inline.BITAND[c, 37B]]]};
-- ENTRY PROCEDURES
ProcessKeyboard: PROC =
BEGIN
old, new: Keyarray;
kp: LONG POINTER TO Keyarray = LOOPHOLE[UserTerminal.keyboard];
blinkCount: CARDINAL ← 33;
GoAway: ENTRY PROC [m: POINTER TO MONITORLOCK] RETURNS [BOOLEAN] = INLINE {
IF shuttingDown
THEN {shuttingDown ← FALSE; BROADCAST shutDown; RETURN[TRUE]}
ELSE RETURN[FALSE]};
WaitStart: ENTRY PROC [m: POINTER TO MONITORLOCK] = INLINE {
WHILE ~startingUp DO WAIT startUp; ENDLOOP};
Process.SetPriority[6];
new ← kp↑;
WHILE TRUE DO
Brdcst: ENTRY PROC [m: POINTER TO MONITORLOCK] =
INLINE {BROADCAST charactersAvailable};
charsSeen: BOOLEAN ← FALSE;
IF GoAway[@keyboardLock] THEN WaitStart[@keyboardLock];
startingUp ← FALSE;
old ← new;
UserTerminal.WaitForScanLine[0];
new ← kp↑;
TrackCursor[@keyboardLock];
IF (blinkCount←blinkCount-1) = 0 THEN {BlinkCursor[]; blinkCount ← 34};
FOR i: CARDINAL IN [1..keycount/16) DO
IF old.wds[i]#new.wds[i] THEN
FOR j: CARDINAL IN [i*16..(i+1)*16) DO
char: CHARACTER;
entry: KeyItem;
IF new.bits[j]=up OR old.bits[j]=down THEN LOOP;
IF (char ← (entry←KeyTable[j]).NormalCode)#0C THEN
BEGIN
SELECT TRUE FROM
new.bits[ctrl]=down =>
IF char=177C THEN {CDT ← TRUE; LOOP} ELSE char ← CtrlChar[char];
new.bits[leftShift]=down, new.bits[rightShift]=down =>
char ← entry.ShiftCode;
new.bits[shiftLock]=down AND entry.Letter =>
char ← entry.ShiftCode;
ENDCASE;
StuffBuffer[char, @keyboardLock];
charsSeen ← TRUE
END;
ENDLOOP
ENDLOOP;
IF charsSeen THEN Brdcst[@keyboardLock];
ENDLOOP
END;
SetEcho: PUBLIC PROC [h: TTY.Handle, new: BOOLEAN] RETURNS [old: BOOLEAN] =
BEGIN
SetEntry: ENTRY PROC [m: POINTER TO MONITORLOCK] = INLINE {old ← echo; echo ← new};
SetEntry[@keyboardLock]
END;
TrackCursor: ENTRY PROC [m: POINTER TO MONITORLOCK] =
INLINE BEGIN
mouse: UserTerminal.Coordinate ← UserTerminal.mouse↑;
IF noTrack > 0 THEN RETURN;
mouse.x ← MIN[MAX[0, mouse.x], UserTerminal.screenWidth];
mouse.y ← MIN[MAX[0, mouse.y], UserTerminal.screenHeight];
UserTerminal.cursor↑ ← mouse;
UserTerminal.SetMousePosition[mouse]
END;
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Keyboard RingBuffer
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
in, out: CARDINAL;
buffer: PACKED ARRAY [0..50) OF CHARACTER;
CharsAvailable: PUBLIC PROC [h: TTY.Handle] RETURNS [CARDINAL] =
BEGIN
P: ENTRY PROC [m: POINTER TO MONITORLOCK] RETURNS [CARDINAL] =
INLINE {RETURN[IF in>=out THEN in-out ELSE in+LENGTH[buffer]-out]};
RETURN[P[@keyboardLock]]
END;
GetChar: PUBLIC PROC [h: TTY.Handle] RETURNS [c: CHARACTER] =
BEGIN
P: ENTRY PROC [m: POINTER TO MONITORLOCK] =
INLINE BEGIN
WHILE in=out DO WAIT charactersAvailable ENDLOOP;
c ← buffer[out];
IF (out←out+1) = LENGTH[buffer] THEN out ← 0;
END;
P[@keyboardLock]
END;
PutBackChar: PUBLIC PROC [h: TTY.Handle, c: CHARACTER] =
BEGIN
P: ENTRY PROC [m: POINTER TO MONITORLOCK] =
INLINE BEGIN
newout: CARDINAL = IF out=0 THEN LENGTH[buffer]-1 ELSE out-1;
IF newout#in THEN {buffer[out ← newout] ← c; BROADCAST charactersAvailable};
END;
P[@keyboardLock]
END;
ResetUserAbort: PUBLIC PROC =
BEGIN
CDResetEntry: ENTRY PROC [m: POINTER TO MONITORLOCK] = INLINE {CDT ← FALSE};
CDResetEntry[@keyboardLock]
END;
StuffBuffer: ENTRY PROC [c: CHARACTER, m: POINTER TO MONITORLOCK] =
INLINE BEGIN
newin: CARDINAL;
IF (newin←in+1) = LENGTH[buffer] THEN newin ← 0;
IF newin#out THEN {buffer[in] ← c; in ← newin};
END;
-- perhaps this should be monitored, but since it is a snapshot...
UserAbort: PUBLIC PROC RETURNS [BOOLEAN] = {RETURN[CDT]};
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- DISPLAY
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
BBTable: BBTableSpace;
bbPtr: BBptr = AlignedBBTable[@BBTable];
charPos, line, nCharPos, nLines: CARDINAL;
firstLine, thisLine: Environment.BitAddress;
bitsPerTextLine: CARDINAL; -- = screenWidth*font.height
doBlink: BOOLEAN ← FALSE;
-- EXTERNAL DISPLAY PROCEDURES
GetBitAddress: PROC [p: LONG POINTER, o: CARDINAL] RETURNS [Environment.BitAddress] =
{RETURN[[p+o/16, 0, o MOD 16]]};
PutBlanks: PUBLIC PROC [h: TTY.Handle, n: CARDINAL] =
{THROUGH [0..n) DO PutChar[h, ' ] ENDLOOP};
-- ENTRY DISPLAY PROCEDURES
BlinkCursor: PUBLIC PROC =
BEGIN
BlinkCursorEntry: ENTRY PROC [m: POINTER TO MONITORLOCK] =
BEGIN
blinker: CARDINAL ← 60000B;
IF doBlink THEN
BEGIN
bbPtr.src ← [@blinker, 0, 0];
bbPtr.srcDesc ← [gray[[0, 0, 0, 0]]];
bbPtr.flags ← [gray: TRUE, dstFunc: xor];
BITBLT[bbPtr];
bbPtr.srcDesc ← [srcBpl[font.raster*16]];
bbPtr.flags ← [];
END;
END;
IF doBlink THEN BlinkCursorEntry[@screenLock];
END;
NewLine: PUBLIC PROC [TTY.Handle] RETURNS [BOOLEAN] = {RETURN[charPos=0]};
PutChar: PUBLIC PROC [h: TTY.Handle, c: CHARACTER] =
BEGIN
PutCharEntry: ENTRY PROC [m: POINTER TO MONITORLOCK] =
INLINE {doBlink ← FALSE; ClearThisChar[]; DisplayChar[c]; doBlink ← TRUE};
-- PutCharEntry[@screenLock];
END;
PutLongString: PUBLIC PROC [h: TTY.Handle, s: LONG STRING] =
{IF s#NIL THEN FOR i: CARDINAL IN [0..s.length) DO PutChar[h, s[i]] ENDLOOP};
PutString: PUBLIC PROC [h: TTY.Handle, s: STRING] = {PutLongString[h, s]};
-- INTERNAL DISPLAY PROCEDURES
Backup: INTERNAL PROC =
BEGIN
t: CARDINAL = bbPtr.dst.bit+16-font.maxwidth;
IF charPos=0 THEN RETURN;
charPos ← charPos - 1;
bbPtr.dst.word ← bbPtr.dst.word + t/16 - 1;
bbPtr.dst.bit ← t MOD 16;
END;
ClearScreen: INTERNAL PROC =
BEGIN
zero: CARDINAL ← 0;
bbPtr↑ ← UserTerminal.GetBitBltTable[];
bitsPerTextLine ← bbPtr.dstBpl*height;
firstLine ← thisLine ← GetBitAddress[
bbPtr.dst.word, bbPtr.dst.bit+8+8*bbPtr.dstBpl];
charPos ← 0; line ← 1;
nCharPos ← (bbPtr.width-16)/font.maxwidth;
nLines ← (bbPtr.height-16)/height;
bbPtr.src ← [@zero, 0, 0];
bbPtr.srcDesc ← [gray[[0, 0, 0, 0]]];
bbPtr.flags ← [gray: TRUE];
BITBLT[bbPtr];
-- set up standard arguments for character painting
bbPtr.dst ← firstLine;
--bbPtr.dstBpl set
--bbPtr.src set when proc called
bbPtr.srcDesc ← [srcBpl[font.raster*16]];
bbPtr.height ← height;
bbPtr.width ← font.maxwidth;
bbPtr.flags ← [];
END;
ClearThisChar: INTERNAL PROC =
BEGIN
zero: CARDINAL ← 0;
bbPtr.src ← [@zero, 0, 0];
bbPtr.srcDesc ← [gray[[0, 0, 0, 0]]];
bbPtr.flags ← [gray: TRUE];
BITBLT[bbPtr];
bbPtr.srcDesc ← [srcBpl[font.raster*16]];
bbPtr.flags ← [];
END;
DisplayChar: INTERNAL PROC [c: CHARACTER] =
BEGIN
SELECT c FROM
IN (SP..'~] =>
BEGIN
IF c NOT IN [font.min..font.max] THEN c ← font.max+1;
bbPtr.src ← GetBitAddress[bitmap, xInSegment[c]];
BitBlt.BITBLT[bbPtr];
END;
SP => NULL;
CR => {Newline[]; RETURN};
BS => {Backup[]; ClearThisChar[]; RETURN};
TAB => {UNTIL (charPos MOD 8)=0 DO DisplayChar[SP] ENDLOOP; RETURN};
FF => {ClearScreen[]; RETURN};
IN [0C..SP) => {DisplayChar['↑]; DisplayChar[c+('A-1C)]; RETURN};
ENDCASE => RETURN;
IF (charPos←charPos+1)>=nCharPos THEN Newline[]
ELSE bbPtr.dst ← GetBitAddress[bbPtr.dst.word, bbPtr.dst.bit+font.maxwidth];
END;
Newline: INTERNAL PROC =
BEGIN
IF line<nLines THEN
{thisLine ← GetBitAddress[thisLine.word, thisLine.bit+bitsPerTextLine]; line ← line+1}
ELSE
BEGIN
zero: CARDINAL ← 0;
sBBTable: BBTableSpace;
sbbPtr: BBptr = AlignedBBTable[@sBBTable];
sbbPtr↑ ← [
dst: firstLine, dstBpl: bbPtr.dstBpl,
src: GetBitAddress[firstLine.word, firstLine.bit+bitsPerTextLine],
srcDesc: [srcBpl[bbPtr.dstBpl]], flags: [direction: forward],
width: nCharPos*font.maxwidth, height: height*(nLines-1)];
BITBLT[sbbPtr];
sbbPtr↑ ← [
dst: thisLine, src: [@zero, 0, 0],
dstBpl: bbPtr.dstBpl, srcDesc: [gray[[0, 0, 0, 0]]],
width: nCharPos*font.maxwidth, height: height,
flags: [gray: TRUE]];
BITBLT[sbbPtr];
END;
bbPtr.dst ← thisLine;
charPos ← 0;
END;
GetFont: PROC RETURNS [LONG POINTER] =
BEGIN
Gacha12Strike: ARRAY [0..1470B) OF WORD = [
-- 0-- 120000B, 0B, 176B, 10B, 1464B, 13B, 3B, 0B,
-- 10-- 61B, 0B, 0B, 0B, 10000B, 0B, 2040B, 0B,
-- 20-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
-- 30-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
-- 40-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 74B,
-- 50-- 74B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
-- 60-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 7010B,
-- 70-- 70000B, 0B, 0B, 10B, 22012B, 34144B, 14010B, 4020B,
-- 100-- 4000B, 0B, 2B, 36010B, 36074B, 6076B, 36176B, 36074B,
-- 110-- 0B, 2000B, 20074B, 14020B, 74034B, 74176B, 77034B, 41076B,
-- 120-- 17102B, 40306B, 41074B, 76074B, 76074B, 77502B, 40501B, 41101B,
-- 130-- 77040B, 20004B, 0B, 100B, 2B, 14B, 100B, 4004B,
-- 140-- 40070B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
-- 150-- 10010B, 4000B, 0B, 0B, 10B, 22012B, 52244B, 22010B,
-- 160-- 10010B, 25000B, 0B, 2B, 41030B, 41102B, 6040B, 41002B,
-- 170-- 41102B, 0B, 4000B, 10102B, 22020B, 42042B, 42100B, 40042B,
-- 200-- 41010B, 1104B, 40306B, 61102B, 41102B, 41102B, 4102B, 40511B,
-- 210-- 41101B, 1040B, 20004B, 0B, 100B, 2B, 22B, 100B,
-- 220-- 4004B, 40010B, 0B, 0B, 0B, 20B, 0B, 0B,
-- 230-- 0B, 10010B, 4000B, 0B, 0B, 10B, 22024B, 52250B,
-- 240-- 22010B, 10010B, 16010B, 0B, 4B, 41050B, 41102B, 12040B,
-- 250-- 40002B, 41102B, 0B, 10000B, 4102B, 41050B, 42102B, 41100B,
-- 260-- 40102B, 41010B, 1110B, 40252B, 61102B, 41102B, 41102B, 4102B,
-- 270-- 21111B, 22042B, 2040B, 10004B, 4000B, 100B, 2B, 20B,
-- 300-- 100B, 0B, 40010B, 0B, 0B, 0B, 20B, 0B,
-- 310-- 0B, 0B, 10010B, 4000B, 74000B, 0B, 10B, 22076B,
-- 320-- 50310B, 14010B, 20004B, 25010B, 0B, 4B, 43010B, 1002B,
-- 330-- 12174B, 76004B, 41102B, 4010B, 20000B, 2002B, 47050B, 42100B,
-- 340-- 41100B, 40100B, 41010B, 1120B, 40252B, 51102B, 41102B, 41040B,
-- 350-- 4102B, 21111B, 22042B, 4040B, 10004B, 16020B, 34134B, 36072B,
-- 360-- 36174B, 35134B, 34074B, 42010B,167134B, 36134B, 35054B, 36174B,
-- 370-- 41102B,101104B, 41174B, 10010B, 4062B, 74000B, 0B, 10B,
-- 400-- 24B, 34010B, 10000B, 20004B, 4010B, 176B, 10B, 45010B,
-- 410-- 2034B, 22102B, 41004B, 36102B, 4010B, 40176B, 1004B, 51104B,
-- 420-- 76100B, 41174B, 76100B, 77010B, 1160B, 40252B, 51102B, 41102B,
-- 430-- 76030B, 4102B, 21052B, 14024B, 4040B, 4004B, 25040B, 42142B,
-- 440-- 41106B, 41020B, 43142B, 4004B, 44010B,111142B, 41142B, 43062B,
-- 450-- 41020B, 41102B,101104B, 41004B, 10010B, 4132B, 74000B, 0B,
-- 460-- 10B, 50B, 12020B, 24400B, 20004B, 177B, 0B, 10B,
-- 470-- 51010B, 4002B, 22002B, 41010B, 41102B, 0B, 40000B, 1010B,
-- 500-- 51104B, 41100B, 41100B, 40116B, 41010B, 1110B, 40222B, 45102B,
-- 510-- 76102B, 44004B, 4102B, 12052B, 14024B, 10040B, 4004B, 4177B,
-- 520-- 2102B, 40102B, 41020B, 41102B, 4004B, 50010B,111102B, 41102B,
-- 530-- 41040B, 40020B, 41044B,111050B, 21010B, 60010B, 3114B, 74000B,
-- 540-- 35400B, 10B, 174B, 12023B, 45000B, 20004B, 10B, 0B,
-- 550-- 20B, 61010B, 10002B, 42002B, 41010B, 41076B, 0B, 20176B,
-- 560-- 2010B, 46104B, 41100B, 41100B, 40102B, 41010B, 1104B, 40222B,
-- 570-- 45102B, 40102B, 42002B, 4102B, 12052B, 22010B, 20040B, 2004B,
-- 600-- 4040B, 36102B, 40102B, 77020B, 41102B, 4004B, 70010B,111102B,
-- 610-- 41102B, 41040B, 36020B, 41044B,111020B, 22020B, 10010B, 4000B,
-- 620-- 74000B, 0B, 0B, 50B, 52025B, 42000B, 20004B, 10B,
-- 630-- 0B, 20B, 41010B, 20102B, 77102B, 41020B, 41002B, 0B,
-- 640-- 10000B, 4000B, 40376B, 41102B, 41100B, 40102B, 41010B, 41104B,
-- 650-- 40222B, 43102B, 40102B, 42102B, 4102B, 12024B, 22010B, 20040B,
-- 660-- 2004B, 4020B, 42102B, 40102B, 40020B, 41102B, 4004B, 44010B,
-- 670-- 111102B, 41102B, 41040B, 1020B, 41044B,111050B, 12040B, 10010B,
-- 700-- 4000B, 74000B, 0B, 10B, 120B, 52045B, 42000B, 10010B,
-- 710-- 10B, 14000B, 4040B, 41010B, 40102B, 2102B, 41020B, 41102B,
-- 720-- 4030B, 4000B, 10010B, 21202B, 41042B, 42100B, 40046B, 41010B,
-- 730-- 41102B, 40202B, 43102B, 40102B, 41102B, 4102B, 4024B, 41010B,
-- 740-- 40040B, 1004B, 4000B, 42142B, 41106B, 41020B, 43102B, 4004B,
-- 750-- 42010B,111102B, 41142B, 43040B, 41022B, 43030B,111104B, 14100B,
-- 760-- 10010B, 4000B, 74000B, 0B, 10B, 120B, 34046B, 35400B,
-- 770-- 10010B, 0B, 4000B, 4040B, 36076B, 77074B, 2074B, 36020B,
--1000-- 36074B, 4010B, 2000B, 20010B, 16202B, 76034B, 74176B, 40032B,
--1010-- 41076B, 36102B, 77202B, 41074B, 40074B, 41074B, 4074B, 4024B,
--1020-- 41010B, 77040B, 1004B, 0B, 35134B, 36072B, 36020B, 35102B,
--1030-- 4004B, 41010B,111102B, 36134B, 35040B, 36014B, 35030B, 66104B,
--1040-- 4176B, 10010B, 4000B, 74000B, 0B, 0B, 0B, 10000B,
--1050-- 0B, 4020B, 0B, 4000B, 0B, 0B, 0B, 0B,
--1060-- 0B, 0B, 10B, 0B, 0B, 0B, 0B, 0B,
--1070-- 0B, 0B, 0B, 0B, 0B, 20B, 0B, 0B,
--1100-- 0B, 0B, 40B, 4B, 0B, 0B, 0B, 0B,
--1110-- 1000B, 4B, 0B, 0B, 100B, 1000B, 0B, 0B,
--1120-- 0B, 4000B, 10010B, 4000B, 74000B, 0B, 0B, 0B,
--1130-- 0B, 0B, 2040B, 0B, 10000B, 0B, 0B, 0B,
--1140-- 0B, 0B, 0B, 20B, 0B, 0B, 0B, 0B,
--1150-- 0B, 0B, 0B, 0B, 0B, 0B, 16B, 0B,
--1160-- 0B, 0B, 0B, 74B, 74B, 0B, 0B, 0B,
--1170-- 0B, 41000B, 104B, 0B, 0B, 100B, 1000B, 0B,
--1200-- 0B, 0B, 50000B, 7010B, 70000B, 74000B, 377B, 0B,
--1210-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
--1220-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
--1230-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
--1240-- 0B, 0B, 0B, 0B, 0B, 0B, 0B, 0B,
--1250-- 0B, 0B, 36000B, 70B, 0B, 0B, 100B, 1000B,
--1260-- 0B, 0B, 0B, 20000B, 0B, 0B, 74000B, 0B,
--1270-- 10B, 10B, 10B, 10B, 10B, 10B, 10B, 10B,
--1300-- 10B, 10B, 10B, 10B, 10B, 10B, 10B, 10B,
--1310-- 10B, 10B, 10B, 10B, 10B, 10B, 10B, 10B,
--1320-- 20B, 20B, 20B, 20B, 20B, 20B, 20B, 20B,
--1330-- 30B, 40B, 50B, 60B, 70B, 100B, 110B, 120B,
--1340-- 130B, 140B, 150B, 160B, 170B, 200B, 210B, 220B,
--1350-- 230B, 240B, 250B, 260B, 270B, 300B, 310B, 320B,
--1360-- 330B, 340B, 350B, 360B, 370B, 400B, 410B, 420B,
--1370-- 430B, 440B, 450B, 460B, 470B, 500B, 510B, 520B,
--1400-- 530B, 540B, 550B, 560B, 570B, 600B, 610B, 620B,
--1410-- 630B, 640B, 650B, 660B, 670B, 700B, 710B, 720B,
--1420-- 730B, 740B, 750B, 760B, 770B, 1000B, 1010B, 1020B,
--1430-- 1020B, 1030B, 1040B, 1050B, 1060B, 1070B, 1100B, 1110B,
--1440-- 1120B, 1130B, 1140B, 1150B, 1160B, 1170B, 1200B, 1210B,
--1450-- 1220B, 1230B, 1240B, 1250B, 1260B, 1270B, 1300B, 1310B,
--1460-- 1320B, 1330B, 1340B, 1350B, 1360B, 1370B, 1400B, 1410B];
p: LONG POINTER TO ARRAY [0..1470B) OF WORD ← Runtime.GetTableBase[LOOPHOLE[MockingbirdTTY]];
DO
IF p[0] = Gacha12Strike[0] AND p↑ = Gacha12Strike THEN RETURN[p];
p ← p+1;
ENDLOOP;
END;
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- non-basic tty features
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
BackingStream: PUBLIC PROC [TTY.Handle] RETURNS [never: UNSPECIFIED] =
{ERROR};
GetDecimal: PUBLIC PROC [h: TTY.Handle] RETURNS [INTEGER] =
BEGIN
s: STRING ← [10];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToNumber[s, 10]]
END;
GetID: PUBLIC PROC [h: TTY.Handle, s: STRING] =
{[] ← GetEditedString[h, s, IsAtom, TRUE]};
GetLine: PUBLIC PROC [h: TTY.Handle, s: STRING] =
{[] ← GetEditedString[h, s, IsCR, TRUE]; PutChar[h, CR]};
GetLongDecimal: PUBLIC PROC [h: TTY.Handle] RETURNS [n: LONG INTEGER] =
BEGIN
s: STRING ← [32];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToLongNumber[s, 10]]
END;
GetLongNumber: PUBLIC PROC [
h: TTY.Handle, default: LONG UNSPECIFIED, radix: CARDINAL]
RETURNS [n: LONG UNSPECIFIED] =
BEGIN
s: STRING ← [32];
IF radix = 10 AND LOOPHOLE[default, LONG INTEGER] < 0 THEN
{s[0] ← '-; s.length ← 1; default ← -default};
String.AppendLongNumber[s, default, radix];
IF radix = 8 THEN String.AppendChar[s, 'B];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToLongNumber[s, radix]];
END;
GetLongOctal: PUBLIC PROC [h: TTY.Handle] RETURNS [n: LONG UNSPECIFIED] =
BEGIN
s: STRING ← [32];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToLongNumber[s, 8]]
END;
GetNumber: PUBLIC PROC [h: TTY.Handle, default: UNSPECIFIED, radix: CARDINAL]
RETURNS [n: UNSPECIFIED] =
BEGIN
s: STRING ← [10];
IF radix = 10 AND LOOPHOLE[default, INTEGER] < 0 THEN
{default ← -default; s[0] ← '-; s.length ← 1};
String.AppendNumber[s, default, radix];
IF radix = 8 THEN String.AppendChar[s, 'B];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToNumber[s, radix]];
END;
GetOctal: PUBLIC PROC [h: TTY.Handle] RETURNS [n: UNSPECIFIED] =
BEGIN
s: STRING ← [10];
[] ← GetEditedString[h, s, IsAtom, TRUE];
RETURN[String.StringToNumber[s, 8]]
END;
GetString: PUBLIC PROC [
h: TTY.Handle, s: STRING, t: PROC [c: CHARACTER] RETURNS [yes: BOOLEAN]] =
{PutChar[h, GetEditedString[h, s, t, TRUE]]};
LineOverflow: PUBLIC SIGNAL [s: STRING] RETURNS [ns: STRING] = CODE;
Rubout: PUBLIC SIGNAL = CODE;
GetEditedString: PUBLIC PROC [
h: TTY.Handle, s: STRING,
t: PROC [c: CHARACTER] RETURNS [yes: BOOLEAN],
newstring: BOOLEAN]
RETURNS [c: CHARACTER] =
BEGIN
c ← GetChar[h];
IF newstring THEN
IF c = ESC THEN {PutString[h, s]; c ← GetChar[h]} ELSE s.length ← 0;
UNTIL t[c] DO
SELECT c FROM
DEL => SIGNAL Rubout;
ControlA, BS => -- backspace
IF s.length > 0 THEN {IF echo THEN PutChar[h, BS]; s.length ← s.length - 1};
ControlW, ControlQ => -- backword
BEGIN
-- text to be backed up is of the form ...<li><v><ti>, the <v> and <ti> are to
-- be removed.
state: {ti, v, li} ← ti;
FOR i: CARDINAL DECREASING IN [0..s.length) DO
SELECT s[i] FROM
IN ['A..'Z], IN ['a..'z], IN ['0..'9] => IF state = ti THEN state ← v;
ENDCASE => IF state = v THEN state ← li;
IF state = li THEN GO TO Done;
IF echo THEN PutChar[h, BS];
REPEAT
Done => s.length ← i + 1;
FINISHED => s.length ← 0;
ENDLOOP;
END;
ControlX => -- back everything
BEGIN
IF echo THEN FOR i: CARDINAL IN [0..s.length) DO PutChar[h, BS] ENDLOOP;
s.length ← 0;
END;
ControlR => -- refresh-- IF echo THEN {PutChar[h, CR]; PutString[h, s]};
ControlV => -- dont parse next char
BEGIN
WHILE s.length >= s.maxlength DO s ← SIGNAL LineOverflow[s] ENDLOOP;
s[s.length] ← c ← GetChar[h];
s.length ← s.length + 1;
IF echo THEN PutChar[h, c]
END;
ENDCASE =>
BEGIN
WHILE s.length >= s.maxlength DO s ← SIGNAL LineOverflow[s] ENDLOOP;
s[s.length] ← c;
s.length ← s.length + 1;
IF echo THEN PutChar[h, c];
END;
c ← GetChar[h];
ENDLOOP;
END;
IsAtom: PROC [c: CHARACTER] RETURNS [BOOLEAN] = {RETURN[c = SP OR c = CR]};
IsCR: PROC [c: CHARACTER] RETURNS [BOOLEAN] = {RETURN[c = CR]};
-- extended output procedures
OutString: PROC [s: STRING] = {PutLongString[LOOPHOLE[0], s]};
PutDate: PUBLIC PROC [h: TTY.Handle, gmt: Time.Packed, format: TTY.DateFormat] =
{Format.Date[gmt, format, OutString]};
PutDecimal: PUBLIC PROC [h: TTY.Handle, n: INTEGER] = {Format.Decimal[n, OutString]};
PutLongDecimal: PUBLIC PROC [h: TTY.Handle, n: LONG INTEGER] =
{Format.LongDecimal[n, OutString]};
PutLongNumber: PUBLIC PROC [h: TTY.Handle, n: LONG UNSPECIFIED, format: TTY.NumberFormat] =
{Format.LongNumber[n, format, OutString]};
PutLongOctal: PUBLIC PROC [h: TTY.Handle, n: LONG UNSPECIFIED] =
{Format.LongOctal[n, OutString]};
PutNumber: PUBLIC PROC [h: TTY.Handle, n: UNSPECIFIED, format: TTY.NumberFormat] =
{Format.Number[n, format, OutString]};
PutOctal: PUBLIC PROC [h: TTY.Handle, n: UNSPECIFIED] = {Format.Octal[n, OutString]};
PutLongSubString: PUBLIC PROC [h: TTY.Handle, ss: TTY.LongSubString] =
{Format.LongSubStringItem[ss, OutString]};
PutSubString: PUBLIC PROC [h: TTY.Handle, ss: String.SubString] =
{Format.SubString[ss, OutString]};
Initialize[];
END.