-- 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.