HalfMinute's suggestion is a good one. I was about to post the same. Output from dosbox and pcem may be generated by the equivalent of printf statements, especially powerful given dosbox works with DOS/V.

I should re-read your posts to see the meaning of the /HS parameter. Also, perhaps there is an internet post about the changes to dosbox (or another emulator) so that DOS/V works. However, I haven't read that another has to boot a disk to start DOS/V: https://sites.google.com/site/csmth96/dosvondosbox.

"I think that's because it uses a 640x475 mode (since it uses a 8x19 font for the single-byte SBCS characters) that PCem doesn't recognize. Therefore, it seems PCem's hardware scrolling doesn't work well in that mode."

Is this video mode implemented by the previously mentioned driver? Do any of the emulators include a line to natively implement this mode?

Yeah, the floppy-less solution exists too for DOSBox, but it uses some third-party DBCS display driver that isn't well-compatible with things like Windows 3.1 Japanese. And Microsoft's DBCS display driver doesn't work on DOSBox because it needs COUNTRY support which DOSBox still doesn't offer.
Also, /HS controls whether hardware scrolling is used or not, and what mode is using.
As for the 640x475 mode, it's pretty much implemented on top of VGA's 640x480 mode, and in a way that is compatible with any graphics adapter following at least the VGA standard. And evidentely, whatever hardware scrolling mode JDISP.SYS uses by default, is I guess not well-documented and therefore apparently not supported by anything other than real graphics cards, DOSBox, Virtual PC, and VMWare Workstation 7 and higher.

Also, while I'm already fixing bugs in PCem, I decided to rewrite the Windows keyboard handler too. Not only it used DirectInput which Microsoft themselves advise against use it because it, as I confirmed with my own testing too, epicly fails on all non-US keyboards and keyboard layouts, but it also used it incorrectly (converting DIK_ key codes to scan codes with a lookup table, when DIK_ key codes are already scan codes). I rewrote it using GetKeyState and MapVirtualKey, which now causes non-US keys such as the one after left Shift (scan code 0x56) to get passed properly, but it still epicly fails on non-US keyboard layouts - when I switch to Japanese keyboard layout in Windows, PCem (but Virtual PC too!) sees the keys all wrong, the Yen key (scan code 0x7D) comes into PCem as 0x2B (regular backslash key). I need to see if win-keyboard.cc can be rewritten even further, to use the raw input Windows messages, so I can then have it just pass the raw scan codes to the emulated machine. That should then fix all the problems.
However, Microsoft are the ones to blame for the keyboard mess, since the Windows keyboard API set is just bad.

PcEm is compiled to use ASCII layout. You may try to either compile it with UNICODE define, or switch to DIrectInput8 and pass IID_IDirectInput8W as parameter in DIrectInput8Create function.
msdn.microsoft.com/en-us/library/window ... s.85).aspx

It looks like you're making good progress. 😀 Perhaps it would be simpler to implement the DOS/V capability with use of documented examples (from other emulators), before revisiting the 3.1(J) support.

Well, I'd say Microsoft's own DOS/V drivers are the standard in this case. The only problem is, we obviously doesn't have the source code of Microsoft's JDISP.SYS. If we did, everything would be much simpler, since we'd just need to look there to see what it does.

HalfMinute wrote:

PcEm is compiled to use ASCII layout. You may try to either compile it with UNICODE define, or switch to DIrectInput8 and pass IID_IDirectInput8W as parameter in DIrectInput8Create function.
msdn.microsoft.com/en-us/library/window ... s.85).aspx

Where do I change the ASCII/UNICODE define?

Edit: Nevermind. I now managed to make PCem listen to the windows WM_INPUT message for raw keyboard input and use that. Works like a charm. But alas, this completely bypassed Windows key remappings too (the ones done with a certain Registry key, that is), so I need to look into reading the Registry in C so I can read the relevant key myself and remap accordingly. Also, for some reason I now get a DirectInput-related crash if I enable the mouse stuff, so I am keeping that disabled until I can fix it.
Or maybe I could add a config setting for key remapping.

Still looking into the S3 Trio64 problems too. Any 32-bit color render is screwed up, even in low resolutions, and it insists at reporting 2 MB of its own memory even though the CRTC is patched to the 4 MB value in the relevant init procedure to the correct option. So time to find what all can affect that. It reports 2 MB video RAM even in a ROM I specifically patched to write in the 4 MB RAM value into the CRTC (something I originally did for Virtual PC 2007 but is coming in useful here too).

And of course, the investigation in what causes DOS/V to black-screen and freeze is on-going too.

I got the virtual Tseng Labs ET4000AX to work in true color mode by opening the vid_unk_ramdac.c file and replacing the following lines:

1case 0: case 1: case 2: case 3:
2svga->bpp = 8;
3break;
4case 6: case 7:
5svga->bpp = 24;
6break;
7case 8: case 9: case 0xA: case 0xB:
8svga->bpp = 15;
9break;
10case 0xC: case 0xD: case 0xE: case 0xF:
11svga->bpp = 16;
12break;

by these ones:

1case 0: case 1: case 2: case 3:
2svga->bpp = 8;
3break;
4case 6: case 7:
5svga->bpp = 15;
6break;
7case 8: case 9: case 0xA: case 0xB:
8svga->bpp = 16;
9break;
10case 0xC: case 0xD: case 0xE: case 0xF:
11svga->bpp = 24;
12break;

Keyboard handling rewrite is done, it even respects the mapping at "ScanCode" at HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout now, and I also made it pass on scan codes 0xF1 (make, no break) and 0xF2 (make, no break) correctly (these are the Hancha and HanYong keys found on Korean keyboards). Now the OS inside PCem sees all keys correctly. Now I need to get mouse working again.

Still working on the two video problems, though.

Windows95Fan wrote:

I got the virtual Tseng Labs ET4000AX to work in true color mode by opening the vid_unk_ramdac.c file and replacing the following lines:

Yes, but do you know what RAMDAC it's now emulating?

SarahWalker wrote:

Windows95Fan wrote:

I got the virtual Tseng Labs ET4000AX to work in true color mode by opening the vid_unk_ramdac.c file and replacing the following lines:

Yes, but do you know what RAMDAC it's now emulating?

According to the first three lines of the vid_unk_ramdac.c file:

1/*It is unknown exactly what RAMDAC this is
2  It is possibly a Sierra 1502x
3  It's addressed by the TLIVESA1 driver for ET4000*/

SarahWalker:

• Why Award BIOSes beep too fast on PCem?
• Can you please add support for the SiS 471 chipset?

Forked out the S3 Trio64 a bit, now there's 3 of them:
- 9FX Vision Trio64: 9FX BIOS, 1 MB VRAM, identifies as Trio64;
- Phoenix S3 Trio64: Phoenix Trio64 BIOS, 4 MB VRAM, identifies as Trio64;
- Phoenix S3 Trio32: Phoenix Trio32 BIOS, 2 MB VRAM, identifies as Trio32.
Now to get back to fixing the 32-bit color mode renderer for the Trio. I am comparing the PCem Trio source code with DOSBox's to see where they differ. Will do the same with generic VGA to see why DOS/V on PCem puts PCem into 320x480(!) mode and freezes, while works fine in DOSBox.

Windows95Fan wrote:

According to the first three lines of the vid_unk_ramdac.c file: […]
Show full quote

According to the first three lines of the vid_unk_ramdac.c file:

Copy code to clipboard

1/*It is unknown exactly what RAMDAC this is
2  It is possibly a Sierra 1502x
3  It's addressed by the TLIVESA1 driver for ET4000*/

Yes, but can you confirm this? Those notes are merely me guessing.

Whew, did more work on the keyboard handling. Made all known escaped keys (those beginning with E0) sent, and even devised a way to disambiguate eg. E0 71 from F1 and E0 F1, and so on. Also noticed it was incorrectly passing E0 8A as the break code of E0 2A (fake shift issued by some keys) instead of the correct E0 AA, so I just fixed that.

Still haven't figured out a solution to the two video problems, but I'm working on that.

Can you give a screenshot of the Trio 32-bit errors? It might be a blitter issue, but I'd like to confirm that.

This is it: http://goput.it/v/hmmf.png . Colors are completely screwed up, and fonts aren't rendering correctly.

Also, found another bug, on all video adapters - in some 256-color modes, only the top quarter of the screen is rendered. This is an example: http://goput.it/v/6782.png .

In the top quarter issue, could you tell me what is running so I have a chance of reproducing it?

In fact, as a general request to everyone, could bug reports please come with as much detail as possible? What program triggers the issue (what version if possible), what OS is running, what drivers (eg in this case VESA driver looks relevant), what system configuration in the emulator, what version of the emulator (normal release, or what revision off the source repo, or something you've been hacking with).

- SarahWalker: About the top quarter issue, what's running it Little Big Adventure 2, a game from 1997 for DOS and Windows 95, this is specifically the DOS version running that uses DOS4GW. The OS is MS-DOS 6.00. System Configuration: Award VX430 with WinChip 240. S3 Trio64 card (but the problem also happens with any other card, such as ATI Mach). PCem version 8.1 latest revision.

By the way, this is the changes I did to the keyboard handling:

• In WIN.C:
  • I added this:
    Copy code to clipboard

    1#define  _WIN32_WINNT 0x0501
    

    In the very beginning.
  • Near the beginning, I also added this:
    Copy code to clipboard

    1RAWINPUTDEVICE device;
    

  • I added these two procedures before WinMain:
    Copy code to clipboard

    1UINT16 convert_scan_code(UINT16 scan_code) {
    2	switch(scan_code) {
    3		// This is so we can disambiguate scan codes that would otherwise conflict and get passed on incorrectly.
    4		case 0xE001:
    5			return 0xF001;
    6		case 0xE002:
    7			return 0xF002;
    8		case 0xE005:
    9			return 0xF005;
    10		case 0xE006:
    11			return 0xF006;
    12		case 0xE007:
    13			return 0xF007;
    14		case 0xE071:
    15			return 0xF008;
    16		case 0xE072:
    17			return 0xF009;
    18		case 0xE07F:
    19			return 0xF00A;
    20		case 0xE0E1:
    21			return 0xF00B;
    22		case 0xE0EE:
    23			return 0xF00C;
    24		case 0xE0F1:
    25			return 0xF00D;
    26		case 0xE0FE:
    27			return 0xF00E;
    28		case 0xE0EF:
    29			return 0xF00F;
    30		default:
    31			return scan_code;
    32	}
    33}
    34
    35void get_registry_key_map() {
    36	char *keyName = "SYSTEM\\CurrentControlSet\\Control\\Keyboard Layout";
    37	char *valueName = "Scancode Map";
    38	char *buf = malloc(32768);
    39	LPDWORD bufSize;
    40	HKEY hKey;
    41	int j = 0;
    42	int k = 0;
    43	int l = 0;
    44	int m = 0;
    45	UINT16 *bufEx;
    46	UINT32 *bufEx2;
    47
    48	pclog("Preparing unaltered scan code map list... ");
    49	for (j = 0; j < 65536; j++) {
    50		ScanCodeMap[j] = convert_scan_code(j);
    51	}
    52	pclog("done!\n");
    53
    54	bufSize = (LPDWORD) malloc(4);
    55	*bufSize = 32768;
    56	pclog("Preparing scan code map list...\n");
    57	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName, 0, 1, &hKey) == ERROR_SUCCESS) {
    58		if(RegQueryValueEx(hKey, valueName, NULL, NULL, buf, bufSize) == ERROR_SUCCESS) {
    59			bufEx2 = (UINT32 *) buf;
    60			scMapCount = bufEx2[2];
    

    …Show last 19 lines

    61			pclog("%lu scan code mappings found!\n", scMapCount);
    62			if ((bufSize != 0) && (scMapCount != 0)) {
    63				pclog("More than zero scan code mappings found, processing...\n");
    64				bufEx = (UINT16 *) (buf + 12);
    65				for (j = 0; j < scMapCount; j++) {
    66					k = j * 2;
    67					l = bufEx[k + 1];
    68					m = bufEx[k];
    69					m = convert_scan_code(m);
    70					ScanCodeMap[l] = m;
    71					pclog("Scan code mapping %u detected: %X -> %X\n", j, l, ScanCodeMap[l]);
    72				}
    73				pclog("Done processing!\n");
    74			}
    75		}
    76		RegCloseKey(hKey);
    77	}
    78	pclog("Done preparing!\n");
    79}
    

  • Changed this:
    Copy code to clipboard

    1        /* Make the window visible on the screen */
    2        ShowWindow (hwnd, nFunsterStil);
    3
    4//        win_set_window(hwnd);
    5
    6        ghwnd=hwnd;
    

    To this:
    Copy code to clipboard

    1        /* Make the window visible on the screen */
    2        ShowWindow (hwnd, nFunsterStil);
    3
    4//        win_set_window(hwnd);
    5        memset(rawinputkey, 0, sizeof(rawinputkey));
    6	device.usUsagePage = 0x01;
    7	device.usUsage = 0x06;
    8	device.dwFlags = RIDEV_NOLEGACY;
    9	device.hwndTarget = hwnd;
    10	e = RegisterRawInputDevices(&device, 1, sizeof(device));
    11	if (e)
    12		pclog("Raw input registered!\n");
    13	else
    14		pclog("Raw input registration failed!\n");
    15
    16	get_registry_key_map();
    17
    18        ghwnd=hwnd;
    

  • In WindowProcedure, I first added this:
    Copy code to clipboard

    1	int c, d, e, f, g;
    2	char buffer[sizeof(RAWINPUT)] = {};
    3	UINT size = sizeof(RAWINPUT);
    4	char *tempmsg = (char *) malloc(256);
    

    in the beginning.
    Then, I added this:
    Copy code to clipboard

    1		case WM_INPUT:
    2			GetRawInputData((HRAWINPUT)(lParam), RID_INPUT, buffer, &size, sizeof(RAWINPUTHEADER));
    3 
    4			RAWINPUT* raw = (RAWINPUT*)(buffer);
    5			if (raw->header.dwType == RIM_TYPEKEYBOARD)
    6			{
    7				const RAWKEYBOARD rawKB = raw->data.keyboard;
    8
    9				c = rawKB.MakeCode;
    10				d = rawKB.VKey;
    11				e = rawKB.Flags;
    12				pclog("Keyboard input received: S:%X VK:%X F:%X\n", c, d, e);
    13
    14				if (d == VK_SHIFT)
    15				{
    16					d = MapVirtualKeyW(c, 3);
    17				}
    18				else if (d == VK_NUMLOCK)
    19				{
    20					c = (MapVirtualKey(d, 0) | 0x100);
    21				}
    22				if (!(e & 4)) {
    23					if (!(e & 1))  f = 0x80;
    24					if (e & 1)  f = 0;
    25					if (e & 2)  c |= 0xE000;
    26					c = ScanCodeMap[c];
    27					g = c & 0xFF00;
    28					if (g == 0xF000)
    29						c |= 0x100;
    30					else if (g == 0xE000)
    31						c |= 0x80;
    32					c &= 0x1FF;
    33					g &= 0xF00;
    34					if (!g)  rawinputkey[c] = f;
    35				}
    36			}
    37			break;
    

    Before the case WM_SETFOCUS .
• Changed WIN_KEYBOARD.CC to:
  Copy code to clipboard

  1#define UNICODE
  2#include <stdio.h>
  3#include <string.h>
  4#include <stdint.h>
  5#define BITMAP WINDOWS_BITMAP
  6#undef BITMAP
  7#include "plat-keyboard.h"
  8#include "win.h"
  9#include "video.h"
  10
  11extern "C" int key[272];
  12
  13extern "C" void fatal(const char *format, ...);
  14extern "C" void pclog(const char *format, ...);
  15
  16extern "C" void keyboard_init();
  17extern "C" void keyboard_close();
  18extern "C" void keyboard_poll();
  19
  20LPDIRECTINPUT lpdi = NULL;
  21LPDIRECTINPUTDEVICE lpdi_key = NULL;
  22
  23void keyboard_init()
  24{
  25        atexit(keyboard_close);
  26        
  27        memset(key, 0, sizeof(key));
  28	pclog("Keyboard initialized!\n");
  29}
  30
  31void keyboard_close()
  32{
  33}
  34
  35void keyboard_poll_host()
  36{
  37        int c, d, e, f;
  38	pclog("Keyboard polling started!\n");
  39
  40        for (c = 0; c < 272; c++) {
  41		key[c] = rawinputkey[c];
  42		if (key[c]) pclog("Key down %i %02X\n", c, c);		
  43	}
  44
  45	pclog("Keyboard polling ended!\n");
  46}
  

• PLAT_KEYBOARD.C now looks like this:
  Copy code to clipboard

  1#ifdef __cplusplus
  2extern "C" {
  3#endif
  4        void keyboard_init();
  5        void keyboard_close();
  6        void keyboard_poll_host();
  7        int key[272];
  8	int rawinputkey[272];
  9	int scMapCount;
  10	// This is for easier searching
  11	unsigned short int ScanCodeMap[65536];
  12        
  13        #define KEY_LCONTROL 0x1d
  14        #define KEY_RCONTROL (0x1d | 0x80)
  15        #define KEY_END      (0x4f | 0x80)
  16#ifdef __cplusplus
  17}
  18#endif
  

• In WIN_MOUSE.CC, added this:
  Copy code to clipboard

  1#define DIRECTINPUT_VERSION	0x0800
  

  in the beginning, and this:
  Copy code to clipboard

  1        if (FAILED(DirectInput8Create(hinstance, (DWORD) DIRECTINPUT_VERSION, IID_IDirectInput8, (LPVOID *) &lpdi, NULL)))
  2           fatal("install_keyboard : DirectInput8Create failed\n");
  

  Before:
  Copy code to clipboard

  1        if (FAILED(lpdi->CreateDevice(GUID_SysMouse, &lpdi_mouse, NULL)))
  2           fatal("mouse_init : CreateDevice failed\n");
  

• KEYBOARD.C now looks like this:
  Copy code to clipboard

  1#include "ibm.h"
  2#include "plat-keyboard.h"
  3#include "keyboard.h"
  4
  5int keybsendcallback = 0;
  6
  7typedef struct
  8{
  9        int scancodes_make[8];
  10        int scancodes_break[8];        
  11} scancode;
  12
  13// 272 = 256 + 16 fake interim scan-codes for disambiguation purposes.
  14// Note: I also changed all instances of E0 8A as break code of E0 2A (fake shift) to the correct E0 AA.
  15static scancode scancode_set1[272] =
  16{
  17        { {-1},       {-1} },       { {0x01, -1}, {0x81, -1} }, { {0x02, -1}, {0x82, -1} }, { {0x03, -1}, {0x83, -1} },
  18        { {0x04, -1}, {0x84, -1} }, { {0x05, -1}, {0x85, -1} }, { {0x06, -1}, {0x86, -1} }, { {0x07, -1}, {0x87, -1} },
  19        { {0x08, -1}, {0x88, -1} }, { {0x09, -1}, {0x89, -1} }, { {0x0a, -1}, {0x8a, -1} }, { {0x0b, -1}, {0x8b, -1} },
  20        { {0x0c, -1}, {0x8c, -1} }, { {0x0d, -1}, {0x8d, -1} }, { {0x0e, -1}, {0x8e, -1} }, { {0x0f, -1}, {0x8f, -1} },
  21        { {0x10, -1}, {0x90, -1} }, { {0x11, -1}, {0x91, -1} }, { {0x12, -1}, {0x92, -1} }, { {0x13, -1}, {0x93, -1} },
  22        { {0x14, -1}, {0x94, -1} }, { {0x15, -1}, {0x95, -1} }, { {0x16, -1}, {0x96, -1} }, { {0x17, -1}, {0x97, -1} },
  23        { {0x18, -1}, {0x98, -1} }, { {0x19, -1}, {0x99, -1} }, { {0x1a, -1}, {0x9a, -1} }, { {0x1b, -1}, {0x9b, -1} },
  24        { {0x1c, -1}, {0x9c, -1} }, { {0x1d, -1}, {0x9d, -1} }, { {0x1e, -1}, {0x9e, -1} }, { {0x1f, -1}, {0x9f, -1} },
  25        { {0x20, -1}, {0xa0, -1} }, { {0x21, -1}, {0xa1, -1} }, { {0x22, -1}, {0xa2, -1} }, { {0x23, -1}, {0xa3, -1} },
  26        { {0x24, -1}, {0xa4, -1} }, { {0x25, -1}, {0xa5, -1} }, { {0x26, -1}, {0xa6, -1} }, { {0x27, -1}, {0xa7, -1} },
  27        { {0x28, -1}, {0xa8, -1} }, { {0x29, -1}, {0xa9, -1} }, { {0x2a, -1}, {0xaa, -1} }, { {0x2b, -1}, {0xab, -1} },
  28        { {0x2c, -1}, {0xac, -1} }, { {0x2d, -1}, {0xad, -1} }, { {0x2e, -1}, {0xae, -1} }, { {0x2f, -1}, {0xaf, -1} },
  29        { {0x30, -1}, {0xb0, -1} }, { {0x31, -1}, {0xb1, -1} }, { {0x32, -1}, {0xb2, -1} }, { {0x33, -1}, {0xb3, -1} },
  30        { {0x34, -1}, {0xb4, -1} }, { {0x35, -1}, {0xb5, -1} }, { {0x36, -1}, {0xb6, -1} }, { {0x37, -1}, {0xb7, -1} },
  31        { {0x38, -1}, {0xb8, -1} }, { {0x39, -1}, {0xb9, -1} }, { {0x3a, -1}, {0xba, -1} }, { {0x3b, -1}, {0xbb, -1} },
  32        { {0x3c, -1}, {0xbc, -1} }, { {0x3d, -1}, {0xbd, -1} }, { {0x3e, -1}, {0xbe, -1} }, { {0x3f, -1}, {0xbf, -1} },
  33        { {0x40, -1}, {0xc0, -1} }, { {0x41, -1}, {0xc1, -1} }, { {0x42, -1}, {0xc2, -1} }, { {0x43, -1}, {0xc3, -1} },
  34        { {0x44, -1}, {0xc4, -1} }, { {0x45, -1}, {0xc5, -1} }, { {0x46, -1}, {0xc6, -1} }, { {0x47, -1}, {0xc7, -1} },
  35        { {0x48, -1}, {0xc8, -1} }, { {0x49, -1}, {0xc9, -1} }, { {0x4a, -1}, {0xca, -1} }, { {0x4b, -1}, {0xcb, -1} },
  36        { {0x4c, -1}, {0xcc, -1} }, { {0x4d, -1}, {0xcd, -1} }, { {0x4e, -1}, {0xce, -1} }, { {0x4f, -1}, {0xcf, -1} },
  37        { {0x50, -1}, {0xd0, -1} }, { {0x51, -1}, {0xd1, -1} }, { {0x52, -1}, {0xd2, -1} }, { {0x53, -1}, {0xd3, -1} },
  38        { {0x54, -1}, {0xd4, -1} }, { {0x55, -1}, {0xd5, -1} }, { {0x56, -1}, {0xd6, -1} }, { {0x57, -1}, {0xd7, -1} },
  39        { {0x58, -1}, {0xd8, -1} }, { {0x59, -1}, {0xd9, -1} }, { {0x5a, -1}, {0xda, -1} }, { {0x5b, -1}, {0xdb, -1} },
  40        { {0x5c, -1}, {0xdc, -1} }, { {0x5d, -1}, {0xdd, -1} }, { {0x5e, -1}, {0xde, -1} }, { {0x5f, -1}, {0xdf, -1} },
  41        { {0x60, -1}, {0xe0, -1} }, { {0x61, -1}, {0xe1, -1} }, { {0x62, -1}, {0xe2, -1} }, { {0x63, -1}, {0xe3, -1} },
  42        { {0x64, -1}, {0xe4, -1} }, { {0x65, -1}, {0xe5, -1} }, { {0x66, -1}, {0xe6, -1} }, { {0x67, -1}, {0xe7, -1} },
  43        { {0x68, -1}, {0xe8, -1} }, { {0x69, -1}, {0xe9, -1} }, { {0x6a, -1}, {0xea, -1} }, { {0x6b, -1}, {0xeb, -1} },
  44        { {0x6c, -1}, {0xec, -1} }, { {0x6d, -1}, {0xed, -1} }, { {0x6e, -1}, {0xee, -1} }, { {0x6f, -1}, {0xef, -1} },
  45        { {0x70, -1}, {0xf0, -1} }, { {0x71, -1}, {0xf1, -1} }, { {0x72, -1}, {0xf2, -1} }, { {0x73, -1}, {0xf3, -1} },
  46        { {0x74, -1}, {0xf4, -1} }, { {0x75, -1}, {0xf5, -1} }, { {0x76, -1}, {0xf6, -1} }, { {0x77, -1}, {0xf7, -1} },
  47        { {0x78, -1}, {0xf8, -1} }, { {0x79, -1}, {0xf9, -1} }, { {0x7a, -1}, {0xfa, -1} }, { {0x7b, -1}, {0xfb, -1} },
  48        { {0x7c, -1}, {0xfc, -1} }, { {0x7d, -1}, {0xfd, -1} }, { {0x7e, -1}, {0xfe, -1} }, { {0x7f, -1}, {0xff, -1} },
  49
  50        { {0x80, -1},       {-1} },             { {0x81, -1},       {-1} },             { {0x82, -1},       {-1} },             { {0xe0, 0x03, -1}, {0xe0, 0x83, -1} }, /*80*/
  51        { {0xe0, 0x04, -1}, {0xe0, 0x84, -1} }, { {0x85, -1},       {-1} },             { {0x86, -1},       {-1} },             { {0x87, -1},       {-1} },             /*84*/
  52        { {0xe0, 0x08, -1}, {0xe0, 0x88, -1} }, { {0xe0, 0x09, -1}, {0xe0, 0x89, -1} }, { {0xe0, 0x0a, -1}, {0xe0, 0x8a, -1} }, { {0xe0, 0x0b, -1}, {0xe0, 0x8b, -1} }, /*88*/
  53        { {0xe0, 0x0c, -1}, {0xe0, 0x8c, -1} }, { {-1},             {-1} },             { {0xe0, 0x0e, -1}, {0xe0, 0x8e, -1} }, { {0xe0, 0x0f, -1}, {0xe0, 0x8f, -1} }, /*8c*/
  54        { {0xe0, 0x10, -1}, {0xe0, 0x90, -1} }, { {0xe0, 0x11, -1}, {0xe0, 0x91, -1} }, { {0xe0, 0x12, -1}, {0xe0, 0x92, -1} }, { {0xe0, 0x13, -1}, {0xe0, 0x93, -1} }, /*90*/
  55        { {0xe0, 0x14, -1}, {0xe0, 0x94, -1} }, { {0xe0, 0x15, -1}, {0xe0, 0x95, -1} }, { {0xe0, 0x16, -1}, {0xe0, 0x96, -1} }, { {0xe0, 0x17, -1}, {0xe0, 0x97, -1} }, /*94*/
  56        { {0xe0, 0x18, -1}, {0xe0, 0x98, -1} }, { {0xe0, 0x19, -1}, {0xe0, 0x99, -1} }, { {0xe0, 0x1a, -1}, {0xe0, 0x9a, -1} }, { {0xe0, 0x1b, -1}, {0xe0, 0x9b, -1} }, /*98*/
  57        { {0xe0, 0x1c, -1}, {0xe0, 0x9c, -1} }, { {0xe0, 0x1d, -1}, {0xe0, 0x9d, -1} }, { {0xe0, 0x1e, -1}, {0xe0, 0x9e, -1} }, { {0xe0, 0x1f, -1}, {0xe0, 0x9f, -1} }, /*9c*/
  58        { {0xe0, 0x20, -1}, {0xe0, 0xa0, -1} }, { {0xe0, 0x21, -1}, {0xe0, 0xa1, -1} }, { {0xe0, 0x22, -1}, {0xe0, 0xa2, -1} }, { {0xe0, 0x23, -1}, {0xe0, 0xa3, -1} }, /*a0*/
  59        { {0xe0, 0x24, -1}, {0xe0, 0xa4, -1} }, { {0xe0, 0x25, -1}, {0xe0, 0xa5, -1} }, { {0xe0, 0x26, -1}, {0xe0, 0xa6, -1} }, { {-1},             {-1} },             /*a4*/
  60        { {-1},             {-1} },             { {-1},             {-1} },             { {0xe0, 0x2a, -1}, {0xe0, 0xaa, -1} }, { {-1},             {-1} },             /*a8*/
  

  …Show last 234 lines

  61        { {0xe0, 0x2c, -1}, {0xe0, 0xac, -1} }, { {0xe0, 0x2d, -1}, {0xe0, 0xad, -1} }, { {0xe0, 0x2e, -1}, {0xe0, 0xae, -1} }, { {0xe0, 0x2f, -1}, {0xe0, 0xaf, -1} }, /*ac*/
  62        { {0xe0, 0x30, -1}, {0xe0, 0xb0, -1} }, { {0xe0, 0x31, -1}, {0xe0, 0xb1, -1} }, { {0xe0, 0x32, -1}, {0xe0, 0xb2, -1} }, { {-1},             {-1} },             /*b0*/
  63        { {0xe0, 0x34, -1}, {0xe0, 0xb4, -1} }, { {0xe0, 0x35, -1}, {0xe0, 0xb5, -1} }, { {0xe0, 0x36, -1}, {0xe0, 0xb6, -1} }, { {0xe0, 0x37, -1}, {0xe0, 0xb7, -1} }, /*b4*/
  64        { {0xe0, 0x38, -1}, {0xe0, 0xb8, -1} }, { {-1},             {-1} },             { {0xe0, 0x3a, -1}, {0xe0, 0xba, -1} }, { {0xe0, 0x3b, -1}, {0xe0, 0xbb, -1} }, /*b8*/
  65        { {0xe0, 0x3c, -1}, {0xe0, 0xbc, -1} }, { {0xe0, 0x3d, -1}, {0xe0, 0xbd, -1} }, { {0xe0, 0x3e, -1}, {0xe0, 0xbe, -1} }, { {0xe0, 0x3f, -1}, {0xe0, 0xbf, -1} }, /*bc*/
  66        { {0xe0, 0x40, -1}, {0xe0, 0xc0, -1} }, { {0xe0, 0x41, -1}, {0xe0, 0xc1, -1} }, { {0xe0, 0x42, -1}, {0xe0, 0xc2, -1} }, { {0xe0, 0x43, -1}, {0xe0, 0xc3, -1} }, /*c0*/
  67        { {0xe0, 0x44, -1}, {0xe0, 0xc4, -1} }, { {-1},             {-1} },             { {0xe0, 0x46, -1}, {0xe0, 0xc6, -1} }, { {0xe0, 0x47, -1}, {0xe0, 0xc7, -1} }, /*c4*/
  68        { {0xe0, 0x48, -1}, {0xe0, 0xc8, -1} }, { {0xe0, 0x49, -1}, {0xe0, 0xc9, -1} }, { {-1},             {-1} },             { {0xe0, 0x4b, -1}, {0xe0, 0xcb, -1} }, /*c8*/
  69        { {0xe0, 0x4c, -1}, {0xe0, 0xcc, -1} }, { {0xe0, 0x4d, -1}, {0xe0, 0xcd, -1} }, { {0xe0, 0x4e, -1}, {0xe0, 0xce, -1} }, { {0xe0, 0x4f, -1}, {0xe0, 0xcf, -1} }, /*cc*/
  70        { {0xe0, 0x50, -1}, {0xe0, 0xd0, -1} }, { {0xe0, 0x51, -1}, {0xe0, 0xd1, -1} }, { {0xe0, 0x52, -1}, {0xe0, 0xd2, -1} }, { {0xe0, 0x53, -1}, {0xe0, 0xd3, -1} }, /*d0*/
  71        { {0xd4, -1},       {-1} },             { {0xe0, 0x55, -1}, {0xe0, 0xd5, -1} }, { {-1},             {-1} },             { {0xe0, 0x57, -1}, {0xe0, 0xd7, -1} }, /*d4*/
  72        { {0xe0, 0x58, -1}, {0xe0, 0xd8, -1} }, { {0xe0, 0x59, -1}, {0xe0, 0xd9, -1} }, { {0xe0, 0x5a, -1}, {0xe0, 0xaa, -1} }, { {0xe0, 0x5b, -1}, {0xe0, 0xdb, -1} }, /*d8*/
  73        { {0xe0, 0x5c, -1}, {0xe0, 0xdc, -1} }, { {0xe0, 0x5d, -1}, {0xe0, 0xdd, -1} }, { {0xe0, 0x5e, -1}, {0xe0, 0xee, -1} }, { {0xe0, 0x5f, -1}, {0xe0, 0xdf, -1} }, /*dc*/
  74        { {-1},             {-1} },             { {0xe0, 0x61, -1}, {0xe0, 0xe1, -1} }, { {0xe0, 0x62, -1}, {0xe0, 0xe2, -1} }, { {0xe0, 0x63, -1}, {0xe0, 0xe3, -1} }, /*e0*/
  75        { {0xe0, 0x64, -1}, {0xe0, 0xe4, -1} }, { {0xe0, 0x65, -1}, {0xe0, 0xe5, -1} }, { {0xe0, 0x66, -1}, {0xe0, 0xe6, -1} }, { {0xe0, 0x67, -1}, {0xe0, 0xe7, -1} }, /*e4*/
  76        { {0xe0, 0x68, -1}, {0xe0, 0xe8, -1} }, { {0xe0, 0x69, -1}, {0xe0, 0xe9, -1} }, { {0xe0, 0x6a, -1}, {0xe0, 0xea, -1} }, { {0xe0, 0x6b, -1}, {0xe0, 0xeb, -1} }, /*e8*/
  77        { {0xe0, 0x6c, -1}, {0xe0, 0xec, -1} }, { {0xe0, 0x6d, -1}, {0xe0, 0xed, -1} }, { {0xe0, 0x6e, -1}, {0xe0, 0xee, -1} }, { {-1},             {-1} },             /*ec*/
  78        { {0xe0, 0x70, -1}, {0xe0, 0xf0, -1} }, { {0xf1, -1},       {-1} },             { {0xf2, -1},       {-1} },             { {0xe0, 0x73, -1}, {0xe0, 0xf3, -1} }, /*f0*/
  79        { {0xe0, 0x74, -1}, {0xe0, 0xf4, -1} }, { {0xe0, 0x75, -1}, {0xe0, 0xf5, -1} }, { {-1},             {-1} },             { {0xe0, 0x77, -1}, {0xe0, 0xf7, -1} }, /*f4*/
  80        { {0xe0, 0x78, -1}, {0xe0, 0xf8, -1} }, { {0xe0, 0x79, -1}, {0xe0, 0xf9, -1} }, { {0xe0, 0x7a, -1}, {0xe0, 0xfa, -1} }, { {0xe0, 0x7b, -1}, {0xe0, 0xfb, -1} }, /*f8*/
  81        { {0xe0, 0x7c, -1}, {0xe0, 0xfc, -1} }, { {0xe0, 0x7d, -1}, {0xe0, 0xfd, -1} }, { {0xe0, 0x7e, -1}, {0xe0, 0xfe, -1} }, { {0xe1, 0x1d, 0x45, 0xe1, 0x9d, 0xc5, -1},             {-1} },  /*fc*/
  82        { {-1},             {-1} },             { {0xe0, 0x01, -1}, {0xe0, 0x81, -1} }, { {0xe0, 0x02, -1}, {0xe0, 0x82, -1} }, { {-1},             {-1} },             /*100*/
  83        { {-1},             {-1} },             { {0xe0, 0x05, -1}, {0xe0, 0x85, -1} }, { {0xe0, 0x06, -1}, {0xe0, 0x86, -1} }, { {0xe0, 0x07, -1}, {0xe0, 0x87, -1} }, /*104*/
  84        { {0xe0, 0x71, -1}, {0xe0, 0xf1, -1} }, { {0xe0, 0x72, -1}, {0xe0, 0xf2, -1} }, { {0xe0, 0x7f, -1}, {0xe0, 0xff, -1} }, { {0xe0, 0xe1, -1}, {-1} },             /*108*/
  85        { {0xe0, 0xee, -1}, {-1} },             { {0xe0, 0xf1, -1}, {-1} },             { {0xe0, 0xfe, -1}, {-1} },             { {0xe0, 0xff, -1}, {-1} }              /*10c*/
  86};
  87
  88/*XT keyboard has no escape scancodes, and no scancodes beyond 53*/
  89static scancode scancode_xt[272] =
  90{
  91        { {-1},       {-1} },       { {0x01, -1}, {0x81, -1} }, { {0x02, -1}, {0x82, -1} }, { {0x03, -1}, {0x83, -1} },
  92        { {0x04, -1}, {0x84, -1} }, { {0x05, -1}, {0x85, -1} }, { {0x06, -1}, {0x86, -1} }, { {0x07, -1}, {0x87, -1} },
  93        { {0x08, -1}, {0x88, -1} }, { {0x09, -1}, {0x89, -1} }, { {0x0a, -1}, {0x8a, -1} }, { {0x0b, -1}, {0x8b, -1} },
  94        { {0x0c, -1}, {0x8c, -1} }, { {0x0d, -1}, {0x8d, -1} }, { {0x0e, -1}, {0x8e, -1} }, { {0x0f, -1}, {0x8f, -1} },
  95        { {0x10, -1}, {0x90, -1} }, { {0x11, -1}, {0x91, -1} }, { {0x12, -1}, {0x92, -1} }, { {0x13, -1}, {0x93, -1} },
  96        { {0x14, -1}, {0x94, -1} }, { {0x15, -1}, {0x95, -1} }, { {0x16, -1}, {0x96, -1} }, { {0x17, -1}, {0x97, -1} },
  97        { {0x18, -1}, {0x98, -1} }, { {0x19, -1}, {0x99, -1} }, { {0x1a, -1}, {0x9a, -1} }, { {0x1b, -1}, {0x9b, -1} },
  98        { {0x1c, -1}, {0x9c, -1} }, { {0x1d, -1}, {0x9d, -1} }, { {0x1e, -1}, {0x9e, -1} }, { {0x1f, -1}, {0x9f, -1} },
  99        { {0x20, -1}, {0xa0, -1} }, { {0x21, -1}, {0xa1, -1} }, { {0x22, -1}, {0xa2, -1} }, { {0x23, -1}, {0xa3, -1} },
  100        { {0x24, -1}, {0xa4, -1} }, { {0x25, -1}, {0xa5, -1} }, { {0x26, -1}, {0xa6, -1} }, { {0x27, -1}, {0xa7, -1} },
  101        { {0x28, -1}, {0xa8, -1} }, { {0x29, -1}, {0xa9, -1} }, { {0x2a, -1}, {0xaa, -1} }, { {0x2b, -1}, {0xab, -1} },
  102        { {0x2c, -1}, {0xac, -1} }, { {0x2d, -1}, {0xad, -1} }, { {0x2e, -1}, {0xae, -1} }, { {0x2f, -1}, {0xaf, -1} },
  103        { {0x30, -1}, {0xb0, -1} }, { {0x31, -1}, {0xb1, -1} }, { {0x32, -1}, {0xb2, -1} }, { {0x33, -1}, {0xb3, -1} },
  104        { {0x34, -1}, {0xb4, -1} }, { {0x35, -1}, {0xb5, -1} }, { {0x36, -1}, {0xb6, -1} }, { {0x37, -1}, {0xb7, -1} },
  105        { {0x38, -1}, {0xb8, -1} }, { {0x39, -1}, {0xb9, -1} }, { {0x3a, -1}, {0xba, -1} }, { {0x3b, -1}, {0xbb, -1} },
  106        { {0x3c, -1}, {0xbc, -1} }, { {0x3d, -1}, {0xbd, -1} }, { {0x3e, -1}, {0xbe, -1} }, { {0x3f, -1}, {0xbf, -1} },
  107        { {0x40, -1}, {0xc0, -1} }, { {0x41, -1}, {0xc1, -1} }, { {0x42, -1}, {0xc2, -1} }, { {0x43, -1}, {0xc3, -1} },
  108        { {0x44, -1}, {0xc4, -1} }, { {0x45, -1}, {0xc5, -1} }, { {0x46, -1}, {0xc6, -1} }, { {0x47, -1}, {0xc7, -1} },
  109        { {0x48, -1}, {0xc8, -1} }, { {0x49, -1}, {0xc9, -1} }, { {0x4a, -1}, {0xca, -1} }, { {0x4b, -1}, {0xcb, -1} },
  110        { {0x4c, -1}, {0xcc, -1} }, { {0x4d, -1}, {0xcd, -1} }, { {0x4e, -1}, {0xce, -1} }, { {0x4f, -1}, {0xcf, -1} },
  111        { {0x50, -1}, {0xd0, -1} }, { {0x51, -1}, {0xd1, -1} }, { {0x52, -1}, {0xd2, -1} }, { {0x53, -1}, {0xd3, -1} },
  112        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*54*/
  113        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*58*/
  114        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*5c*/
  115        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*60*/
  116        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*64*/
  117        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*68*/
  118        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*6c*/
  119        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*70*/
  120        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*74*/
  121        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*78*/
  122        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*7c*/
  123
  124        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*80*/
  125        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*84*/
  126        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*88*/
  127        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*8c*/
  128        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*90*/
  129        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*94*/
  130        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*98*/
  131        { {0x1c, -1}, {0x9c, -1} },             { {0x1d, -1}, {0x9d, -1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*9c*/
  132        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*a0*/
  133        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*a4*/
  134        { {-1},             {-1} },             { {-1},             {-1} },             { {0x2a, -1}, {0xaa, -1} },             { {-1},             {-1} },             /*a8*/
  135        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*ac*/
  136        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*b0*/
  137        { {-1},             {-1} },             { {0x35, -1}, {0xb5, -1} },             { {0x36, -1}, {0xb6, -1} },             { {0x37, -1}, {0xb7, -1} }, /*b4*/
  138        { {0x38, -1}, {0xb8, -1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*b8*/
  139        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*bc*/
  140        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*c0*/
  141        { {-1},             {-1} },             { {-1},             {-1} },             { {0x46, -1}, {0xc6, -1} },             { {0x47, -1}, {0xc7, -1} }, /*c4*/
  142        { {0x48, -1}, {0xc8, -1} },             { {0x49, -1}, {0xc9, -1} },             { {-1},             {-1} },             { {0x4b, -1}, {0xcb, -1} }, /*c8*/
  143        { {-1},             {-1} },             { {0x4d, -1}, {0xcd, -1} },             { {-1},             {-1} },             { {0x4f, -1}, {0xcf, -1} }, /*cc*/
  144        { {0x50, -1}, {0xd0, -1} },             { {0x51, -1}, {0xd1, -1} },             { {0x52, -1}, {0xd2, -1} },             { {0x53, -1}, {0xd3, -1} }, /*d0*/
  145        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*d4*/
  146        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*d8*/
  147        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*dc*/
  148        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e0*/
  149        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e4*/
  150        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e8*/
  151        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*ec*/
  152        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f0*/
  153        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f4*/
  154        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f8*/
  155        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*fc*/
  156        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*100*/
  157        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*104*/
  158        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*108*/
  159        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*10c*/
  160};
  161
  162/*Tandy keyboard has slightly different scancodes to XT*/
  163static scancode scancode_tandy[272] =
  164{
  165        { {-1},       {-1} },       { {0x01, -1}, {0x81, -1} }, { {0x02, -1}, {0x82, -1} }, { {0x03, -1}, {0x83, -1} },
  166        { {0x04, -1}, {0x84, -1} }, { {0x05, -1}, {0x85, -1} }, { {0x06, -1}, {0x86, -1} }, { {0x07, -1}, {0x87, -1} },
  167        { {0x08, -1}, {0x88, -1} }, { {0x09, -1}, {0x89, -1} }, { {0x0a, -1}, {0x8a, -1} }, { {0x0b, -1}, {0x8b, -1} },
  168        { {0x0c, -1}, {0x8c, -1} }, { {0x0d, -1}, {0x8d, -1} }, { {0x0e, -1}, {0x8e, -1} }, { {0x0f, -1}, {0x8f, -1} },
  169        { {0x10, -1}, {0x90, -1} }, { {0x11, -1}, {0x91, -1} }, { {0x12, -1}, {0x92, -1} }, { {0x13, -1}, {0x93, -1} },
  170        { {0x14, -1}, {0x94, -1} }, { {0x15, -1}, {0x95, -1} }, { {0x16, -1}, {0x96, -1} }, { {0x17, -1}, {0x97, -1} },
  171        { {0x18, -1}, {0x98, -1} }, { {0x19, -1}, {0x99, -1} }, { {0x1a, -1}, {0x9a, -1} }, { {0x1b, -1}, {0x9b, -1} },
  172        { {0x1c, -1}, {0x9c, -1} }, { {0x1d, -1}, {0x9d, -1} }, { {0x1e, -1}, {0x9e, -1} }, { {0x1f, -1}, {0x9f, -1} },
  173        { {0x20, -1}, {0xa0, -1} }, { {0x21, -1}, {0xa1, -1} }, { {0x22, -1}, {0xa2, -1} }, { {0x23, -1}, {0xa3, -1} },
  174        { {0x24, -1}, {0xa4, -1} }, { {0x25, -1}, {0xa5, -1} }, { {0x26, -1}, {0xa6, -1} }, { {0x27, -1}, {0xa7, -1} },
  175        { {0x28, -1}, {0xa8, -1} }, { {0x29, -1}, {0xa9, -1} }, { {0x2a, -1}, {0xaa, -1} }, { {0x47, -1}, {0xc7, -1} },
  176        { {0x2c, -1}, {0xac, -1} }, { {0x2d, -1}, {0xad, -1} }, { {0x2e, -1}, {0xae, -1} }, { {0x2f, -1}, {0xaf, -1} },
  177        { {0x30, -1}, {0xb0, -1} }, { {0x31, -1}, {0xb1, -1} }, { {0x32, -1}, {0xb2, -1} }, { {0x33, -1}, {0xb3, -1} },
  178        { {0x34, -1}, {0xb4, -1} }, { {0x35, -1}, {0xb5, -1} }, { {0x36, -1}, {0xb6, -1} }, { {0x37, -1}, {0xb7, -1} },
  179        { {0x38, -1}, {0xb8, -1} }, { {0x39, -1}, {0xb9, -1} }, { {0x3a, -1}, {0xba, -1} }, { {0x3b, -1}, {0xbb, -1} },
  180        { {0x3c, -1}, {0xbc, -1} }, { {0x3d, -1}, {0xbd, -1} }, { {0x3e, -1}, {0xbe, -1} }, { {0x3f, -1}, {0xbf, -1} },
  181        { {0x40, -1}, {0xc0, -1} }, { {0x41, -1}, {0xc1, -1} }, { {0x42, -1}, {0xc2, -1} }, { {0x43, -1}, {0xc3, -1} },
  182        { {0x44, -1}, {0xc4, -1} }, { {0x45, -1}, {0xc5, -1} }, { {0x46, -1}, {0xc6, -1} }, { {0x47, -1}, {0xc7, -1} },
  183        { {0x48, -1}, {0xc8, -1} }, { {0x49, -1}, {0xc9, -1} }, { {0x4a, -1}, {0xca, -1} }, { {0x4b, -1}, {0xcb, -1} },
  184        { {0x4c, -1}, {0xcc, -1} }, { {0x4d, -1}, {0xcd, -1} }, { {0x4e, -1}, {0xce, -1} }, { {0x4f, -1}, {0xcf, -1} },
  185        { {0x50, -1}, {0xd0, -1} }, { {0x51, -1}, {0xd1, -1} }, { {0x52, -1}, {0xd2, -1} }, { {0x56, -1}, {0xd6, -1} },
  186        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*54*/
  187        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*58*/
  188        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*5c*/
  189        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*60*/
  190        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*64*/
  191        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*68*/
  192        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*6c*/
  193        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*70*/
  194        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*74*/
  195        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*78*/
  196        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*7c*/
  197
  198        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*80*/
  199        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*84*/
  200        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*88*/
  201        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*8c*/
  202        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*90*/
  203        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*94*/
  204        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*98*/
  205        { {0x57, -1}, {0xd7, -1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*9c*/
  206        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*a0*/
  207        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*a4*/
  208        { {-1},             {-1} },             { {-1},             {-1} },             { {0x2a, -1}, {0xaa, -1} },             { {-1},             {-1} },             /*a8*/
  209        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*ac*/
  210        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*b0*/
  211        { {-1},             {-1} },             { {0x35, -1}, {0xb5, -1} },             { {0x36, -1}, {0xb6, -1} },             { {0x37, -1}, {0xb7, -1} }, /*b4*/
  212        { {0x38, -1}, {0xb8, -1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*b8*/
  213        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*bc*/
  214        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*c0*/
  215        { {-1},             {-1} },             { {-1},             {-1} },             { {0x46, -1}, {0xc6, -1} },             { {0x47, -1}, {0xc7, -1} }, /*c4*/
  216        { {0x29, -1}, {0xa9, -1} },             { {0x49, -1}, {0xc9, -1} },             { {-1},             {-1} },             { {0x2b, -1}, {0xab, -1} }, /*c8*/
  217        { {-1},             {-1} },             { {0x4e, -1}, {0xce, -1} },             { {-1},             {-1} },             { {0x4f, -1}, {0xcf, -1} }, /*cc*/
  218        { {0x4a, -1}, {0xca, -1} },             { {0x51, -1}, {0xd1, -1} },             { {0x52, -1}, {0xd2, -1} },             { {0x53, -1}, {0xd3, -1} }, /*d0*/
  219        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*d4*/
  220        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*d8*/
  221        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*dc*/
  222        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e0*/
  223        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e4*/
  224        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*e8*/
  225        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*ec*/
  226        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f0*/
  227        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f4*/
  228        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*f8*/
  229        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*fc*/
  230        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*100*/
  231        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*104*/
  232        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*108*/
  233        { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             { {-1},             {-1} },             /*10c*/
  234};
  235static int oldkey[272];
  236static int keydelay[272];
  237
  238void (*keyboard_send)(uint8_t val);
  239void (*keyboard_poll)();
  240int keyboard_scan = 1;
  241
  242void keyboard_process()
  243{
  244        int c;
  245        int d;
  246        scancode *scancodes = (AT) ? scancode_set1 : scancode_xt;
  247        if (!keyboard_scan) return;
  248        if (TANDY) scancodes = scancode_tandy;
  249                
  250        for (c = 0; c < 272; c++)
  251        {
  252                if (key[c]) keydelay[c]++;
  253                else        keydelay[c] = 0;
  254        }
  255        
  256        for (c = 0; c < 272; c++)
  257        {
  258                if (key[c] != oldkey[c])
  259                {
  260                        oldkey[c] = key[c];
  261                        if ( key[c] && scancodes[c].scancodes_make[0]  == -1)
  262                           continue;
  263                        if (!key[c] && scancodes[c].scancodes_break[0] == -1)
  264                           continue;
  265//                        pclog("Key %02X start\n", c);
  266                        d = 0;
  267                        if (key[c])
  268                        {
  269                                while (scancodes[c].scancodes_make[d] != -1)
  270                                      keyboard_send(scancodes[c].scancodes_make[d++]);
  271                        }
  272                        else
  273                        {
  274                                while (scancodes[c].scancodes_break[d] != -1)
  275                                      keyboard_send(scancodes[c].scancodes_break[d++]);
  276                        }
  277                }
  278        }
  279
  280        for (c = 0; c < 272; c++)
  281        {
  282                if (keydelay[c] >= 30)
  283                {
  284                        keydelay[c] -= 10;
  285                        if (scancode_set1[c].scancodes_make[0] == -1)
  286                           continue;
  287                           
  288                        d = 0;
  289
  290                        while (scancode_set1[c].scancodes_make[d] != -1)
  291                              keyboard_send(scancode_set1[c].scancodes_make[d++]);
  292                }
  293        }
  294}
  

Yes, it may look strange that I made it process 272 possible scan codes, but I'm using key states 0x100 to 0x10F to disambiguate some escaped codes from conflicting scan codes (eg. E0 71 from F1 and E0 F1).

Could you use Bitbucket's patch function please? It's much easier to work with.