Parsing ANSI/VT Terminal Keycode Sequences
                       ==========================================
Parsing input from an ANSI keyboard stream can be optimised by combining all keycode
sequences into a superset that represents all sources:

    <esc> {'?' or 'O' or '['} {<num>{;<num>}} {'@'-'~'}

This can be parsed with the following 'C' code. It returns a character code < 0x100
for normal character keys, 0x180+n for function keys, and 0x1C0+n for editing keys.
With function and editing keys, the modifier keys are returned in bit 4 and bit 5.

  unsigned char ansikey[]={                /* Translation table                 */
  0x84,0xCF,0xCE,0xCD,0xCC,0xC5,0xC9,0xCA, /* f4,Up,Dwn,Rgt,Lft,Bgn,End,Nxt     */
  0xC8,0x09,0x1B,0x95,0x94,0x0D,0x00,0x00, /* Hme,Tab,Clr,Shf5,Shf4,Kent,(N),(O)*/
  0x81,0x82,0x83,0x84,0x85,0xCA,0xCB,0x00, /* f1,f2,f3,f4,f5,PgDn,PgUp,(W)      */
  0x3D,0x00,0xD5,0x00,0x00,0x00,0x00,0x00, /* K=,(Y),ShTAB,([),(\),(]),(^),(_)  */
  0x00,0xC8,0xC6,0xC7,0xC9,0xCB,0xCA,0xC8, /* 0,Home,Ins,Del,End,PgUp,PgDn,Home */
  0xC9,0x8D,0x80,0x81,0x82,0x83,0x84,0x85, /* End,Num,F0,F1,F2,F3,F4,F5         */
  0x00,0x86,0x87,0x88,0x89,0x8A,0x00,0x8B, /* (16),F6,F7,F8,F9,F10,(22),F11     */
  0x8C,0x80,0x8E,0x00,0x8F,0xC1,0x00,0x00, /* F12,F13,F14,(27),F15,F16,(30),F17 */
  0x80,0x00,0xC3,0x00                      /* F18,F19,F20,(35)                  */
  }

  int ch=0;				/* Character pressed			*/
  int key=0;				/* Key lookup				*/
  int mod=0;				/* Modifier=<none>			*/
  
  fflush(stdout);
  read(STDIN_FILENO, &ch, 1);		/* Read without flushing		*/
  ch=ch & 0xFF;
  if (ch != 27)     return ch;		/* Not <esc>				*/
  if (kbhit() == 0) return ch;		/* Nothing pending			*/
  
  /* Read an ANSI/VT key sequence as:
   *    <esc> [ (<num>) (;<num>) <0x40-0x7F>
   * or <esc> O <0x40-0x7F>
   * or <esc> ? <0x40-0x7F>
   * or <esc> <0x40-0x7F>
   */

  while ((ch=getchar()) == 27);		/* Get following non-<esc> character	*/
  if (ch=='O' || ch=='?') {		/* Convert <esc>O or <esc>? to <esc>[0	*/
    ch=getchar();			/* Get <esc>?<char> or <esc>O<char>	*/
  } else {
    if (ch=='[') {			/* Parse <esc>[(<nums...><letter>	*/
      while ((ch=getchar())<'@') {	/* Parse through non-alphas		*/
        if (ch>='0' && ch<='9') {	/* Digit, add to current num		*/
          mod=mod*10+(ch-'0');
        }
        if (ch==';') { key=mod; mod=0; } /* Semicolon, parse next number	*/
      }
    }
  }
  if (ch<'@' || ch>0x7F) return ch;	/* Not ...<letter>, return <char>	*/

  /* <esc><char>                mod=0, key=0, ch=<char>
     <esc>?<char>               mod=0, key=0, ch=<char>
     <esc>O<char>               mod=0, key=0, ch=<char>
     <esc>[<char>               mod=0, key=0, ch=<char>
     <esc>[<num><char>          mod=<num>, key=0, ch=<char>
     <esc>[<num1>;<num2><char>  mod=<num2>, key=<num1>, ch=<char>
   */

  if (ch == '~') {				/* <esc>[...~			  */
    if (key == 0) { key=mod; mod=0; }
    key=key+32;
  } else {
    if (ch >= '`') return (ch & 0x3F) | 0x100;	/* <esc>?<lower> or <esc>O<lower> */
    else	   key=(ch & 0x1F);		/* <esc>..<letter>		  */
  }
  if (mod) mod=mod-1;			/* Convert modifiers to bitmap		*/
  ch=ansikey[key];			/* Translate keypress			*/
  if (mod & 1) ch=ch ^ 0x10;		/* SHIFT pressed			*/
  if (mod & 4) ch=ch ^ 0x20;		/* CTRL pressed				*/
  if (mod & 2) ch=ch ^ 0x30;		/* ALT pressed				*/
  return (ch | 0x100);

Example code:
* JGH Console Library         - mdfs.net/System/C/Lib
* PDP11 ANSI parsing          - mdfs.net/Info/Comp/PDP11/ProgTips
* PDP11 BBC BASIC Console I/O - mdfs.net/Software/PDP11/BBCBASIC

References
----------
* invisible-island.net/xterm/ctlseqs/ctlseqs.html
* www.gnu.org/software/screen/manual/html_node/Input-Translation.html#Input-Translation

Updates
-------
22-Jun-2020: Testing suggests malformed sequences are ignored. Slight formatting changes.


- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

ANSI/VT terminal keyboard input sequences are:
   <esc>[ followed by up to 2 8-bit numeric parameters separated by ';' and terminated
          with an uppercase letter or '~',
or <esc>? followed by a single letter,
or <esc>O followed by a single letter,
or <esc> followed by a single uppercase letter.

where <esc> is CHR$27, and "letter" is taken to mean '@' (CHR$64) to <DEL> (CHR$127), and
"uppercase letter" is taken to mean '@' (CHR$64) to '_' (CHR$95). Sometimes a leading <esc>
is followed by another <esc> - parsing code should ignore any additional <esc>s until a
non-<esc> is received.

Keyboard input needs to have the ability to poll the input to see if any characters are
pending without waiting if there are no characters are present, as some sequences are
terminated by the *absense* of a character.

  <char>                               -> <char>
  <esc> <nochar>                       -> <esc>
  <esc> <esc>                          -> loop until non-<esc> received
  <esc> '?' <letter>                   -> keycode sequence
  <esc> <uppercase> (not '[')          -> keycode sequence
  <esc> '[' (<num>) <uppercase>        -> keycode sequence, <num> defaults to 1
  <esc> '[' <num1> (';'<num2>) '~'     -> keycode sequence, <num2> defaults to 1
  <esc> '[' <nochar>                   -> malformed sequence
  otherwise                            -> malformed sequence

If the terminating character is '~', the first number must be present and is a keycode
number, the second number is an optional modifier value. For example:
  <esc>[1~        <esc>[2~        <esc>[1;2~      <esc>[2;4~

If the terminating character is an uppercase letter, the letter is the keycode value, and
the optional or first number is the modifier value. For example:
  <esc>[A         <esc>[B         <esc>[1B        <esc>[2C        <esc>[5D

The modifier value defaults to 1, and after subtracting 1 is a bitmap of modifier keys
being pressed: b3=<Meta>, b2=<Ctrl>, b1=<Alt>, b0=<Shift>. For example:
  <esc>[20~      is key 20               -> function key 9
  <esc>[20;2~    is key 20, modifier 2   -> Shift-function key 9
  <esc>[H        is key H                -> Home
  <esc>[5C       is key C, modifier 5    -> Ctrl-Left

Malformed sequences appear to be ignored and are treated as 'no key pressed'.


These are DEC VT/vt200 sequences
--------------------------------
<esc>[<keynum>(;<modnum>)~

<esc>[1~   - Home/Find   <esc>[16~  - (f5)        <esc>[31~  - F17
<esc>[2~   - Insert      <esc>[17~  - F6          <esc>[32~  - F18 (Print)
<esc>[3~   - Delete      <esc>[18~  - F7          <esc>[33~  - F19 (Cancel)
<esc>[4~   - End/Select  <esc>[19~  - F8          <esc>[34~  - F20 (Pause)
<esc>[5~   - PgUp        <esc>[20~  - F9          <esc>[35~  -
<esc>[6~   - PgDn        <esc>[21~  - F10         <esc>[36~  -
<esc>[7~   - Home        <esc>[22~  -
<esc>[8~   - End         <esc>[23~  - F11
<esc>[9~   -(NumLock)    <esc>[24~  - F12
<esc>[10~  - F0          <esc>[25~  - F13/Print
<esc>[11~  - F1          <esc>[26~  - F14/Scroll
<esc>[12~  - F2          <esc>[27~  -
<esc>[13~  - F3          <esc>[28~  - F15/Break
<esc>[14~  - F4          <esc>[29~  - F16/Menu    <esc>[200~ - start of paste
<esc>[15~  - F5          <esc>[30~  -             <esc>[201~ - end of paste


These are xterm sequences
-------------------------
<esc>[(<modnum>)<uppercase>

<esc>[@  - (output is Insert)
<esc>[A  - Up            <esc>[K  -               <esc>[U  - (output is PageDown)
<esc>[B  - Down          <esc>[L  -               <esc>[V  - (output is PageUp)
<esc>[C  - Right         <esc>[M  -               <esc>[W  -
<esc>[D  - Left          <esc>[N  -               <esc>[X  -
<esc>[E  -               <esc>[O  - vt52/vt100    <esc>[Y  -
<esc>[F  - End           <esc>[1P - F1            <esc>[Z  -
<esc>[G  - Keypad 5      <esc>[1Q - F2            <esc>[[  -
<esc>[H  - Home          <esc>[1R - F3            <esc>[\  -
<esc>[I  -               <esc>[1S - F4            <esc>[^  -
<esc>[J  - Clear         <esc>[T  -               <esc>[_  -

<esc>[A to <esc>[D are the same as the ANSI output sequences. The <modnum> is normally
omitted if no modifier keys are pressed, but most implementations always emit the
<modnum> for F1-F4.


These are vt100 sequences
-------------------------
    <esc>O<letter>
 or <esc>?<letter>

<esc>O@  -                  <esc>OK                  <esc>OV  -
<esc>OA  - Keypad 8 Up      <esc>OL                  <esc>OW  -
<esc>OB  - Keypad 2 Down    <esc>OM  - Keypad Enter  <esc>OX  - Keypad =
<esc>OC  - Keypad 6 Right   <esc>ON                  <esc>OY  -
<esc>OD  - Keypad 4 Left    <esc>OO                  <esc>OZ  -
<esc>OE  - Shift+Keypad 5   <esc>OP  - F1            <esc>O[  -
<esc>OF  - Keypad 1 End     <esc>OQ  - F2            <esc>O\  -
<esc>OG  -                  <esc>OR  - F3            <esc>O]  -
<esc>OH  - Keypad 7 Home    <esc>OS  - F4            <esc>O^  -
<esc>OI  -                  <esc>OT  -               <esc>O_  -
<esc>OJ  -                  <esc>OU  -

Lower case terminators translate directly to Keypad <char-&40>
<esc>O`  -                  <esc>Ok  - Keypad +      <esc>Ov     - Keypad 6
<esc>Oa  -                  <esc>Ol  - Keypad ,      <esc>Ow     - Keypad 7
<esc>Ob  -                  <esc>Om  - Keypad -      <esc>Ox     - Keypad 8
<esc>Oc  -                  <esc>On  - Keypad .      <esc>Oy     - Keypad 9
<esc>Od  -                  <esc>Oo  - Keypad /      <esc>Oz     - Keypad :
<esc>Oe  -                  <esc>Op  - Keypad 0      <esc>O{     - Keypad ;
<esc>Of  -                  <esc>Oq  - Keypad 1      <esc>O|     - Keypad <
<esc>Og  -                  <esc>Or  - Keypad 2      <esc>O}     - Keypad =
<esc>Oh  - Keypad (         <esc>Os  - Keypad 3      <esc>O~     - Keypad >
<esc>Oi  - Keypad )         <esc>Ot  - Keypad 4      <esc>O<7F>  - Keypad ?
<esc>Oj  - Keypad *         <esc>Ou  - Keypad 5

I have not found any documentation on <esc>O` to <esc>Og (and <esc>?` to <esc>?g), but it
is safe to assume they can be treated as keypad keys <20> to <27>.


These are vt52 sequences
------------------------
<esc><uppercase>

<esc>@   -               <esc>L   -               <esc>U   -
<esc>A   - Up            <esc>M   -               <esc>V   -
<esc>B   - Down          <esc>N   -               <esc>W   -
<esc>C   - Right         <esc>OP  - F1            <esc>X   -
<esc>D   - Left          <esc>OQ  - F2            <esc>Y   -
<esc>E   -               <esc>OR  - F3            <esc>Z   -
<esc>F   -               <esc>OS  - F4            <esc>[   - <esc>[ sequence
<esc>G   -               <esc>P   - F1            <esc>\   -
<esc>H   -               <esc>Q   - F2            <esc>]   -
<esc>I   -               <esc>R   - F3            <esc>^   -
<esc>J   -               <esc>S   - F4            <esc>_   -
<esc>K   -               <esc>T   -