2008-02-07 01:58:41 +01:00
|
|
|
#include "termkey.h"
|
|
|
|
|
2008-02-09 20:01:49 +01:00
|
|
|
#include <errno.h>
|
2008-02-07 01:58:41 +01:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
struct termkey {
|
|
|
|
int fd;
|
|
|
|
int flags;
|
|
|
|
unsigned char *buffer;
|
|
|
|
size_t buffvalid;
|
|
|
|
size_t buffsize;
|
|
|
|
|
|
|
|
char is_closed;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
int nkeynames;
|
|
|
|
const char **keynames;
|
|
|
|
|
2008-02-10 18:46:48 +01:00
|
|
|
// There are 32 C0 codes
|
|
|
|
termkey_keysym c0[32];
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
// There are 64 codes 0x40 - 0x7F
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym csi_ss3s[64];
|
|
|
|
termkey_keysym ss3s[64];
|
2008-02-10 18:34:05 +01:00
|
|
|
char ss3_kpalts[64];
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
int ncsifuncs;
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym *csifuncs;
|
2008-02-07 01:58:41 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
termkey_t *termkey_new_full(int fd, int flags, size_t buffsize)
|
|
|
|
{
|
2008-02-10 18:34:05 +01:00
|
|
|
termkey_t *tk = malloc(sizeof(*tk));
|
|
|
|
if(!tk)
|
|
|
|
return NULL;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-09 20:30:37 +01:00
|
|
|
if(!(flags & (TERMKEY_FLAG_RAW|TERMKEY_FLAG_UTF8))) {
|
|
|
|
int locale_is_utf8 = 0;
|
|
|
|
char *e;
|
|
|
|
|
|
|
|
if((e = getenv("LANG")) && strstr(e, "UTF-8"))
|
|
|
|
locale_is_utf8 = 1;
|
|
|
|
|
|
|
|
if(!locale_is_utf8 && (e = getenv("LC_MESSAGES")) && strstr(e, "UTF-8"))
|
|
|
|
locale_is_utf8 = 1;
|
|
|
|
|
|
|
|
if(!locale_is_utf8 && (e = getenv("LC_ALL")) && strstr(e, "UTF-8"))
|
|
|
|
locale_is_utf8 = 1;
|
|
|
|
|
|
|
|
if(locale_is_utf8)
|
|
|
|
flags |= TERMKEY_FLAG_UTF8;
|
|
|
|
else
|
|
|
|
flags |= TERMKEY_FLAG_RAW;
|
|
|
|
}
|
|
|
|
|
2008-02-07 01:58:41 +01:00
|
|
|
tk->fd = fd;
|
|
|
|
tk->flags = flags;
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
tk->buffer = malloc(buffsize);
|
|
|
|
if(!tk->buffer) {
|
|
|
|
free(tk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-07 01:58:41 +01:00
|
|
|
tk->buffvalid = 0;
|
|
|
|
tk->buffsize = buffsize;
|
|
|
|
|
|
|
|
tk->is_closed = 0;
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
int i;
|
2008-02-10 18:46:48 +01:00
|
|
|
|
|
|
|
for(i = 0; i < 32; i++) {
|
|
|
|
tk->c0[i] = TERMKEY_SYM_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
for(i = 0; i < 64; i++) {
|
|
|
|
tk->csi_ss3s[i] = TERMKEY_SYM_UNKNOWN;
|
|
|
|
tk->ss3s[i] = TERMKEY_SYM_UNKNOWN;
|
|
|
|
tk->ss3_kpalts[i] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// These numbers aren't too important; buffers will be grown if insufficient
|
|
|
|
tk->nkeynames = 64;
|
|
|
|
tk->ncsifuncs = 32;
|
|
|
|
|
|
|
|
tk->keynames = malloc(sizeof(tk->keynames[0]) * tk->nkeynames);
|
|
|
|
tk->csifuncs = malloc(sizeof(tk->csifuncs[0]) * tk->ncsifuncs);
|
|
|
|
|
|
|
|
for(i = 0; i < tk->nkeynames; i++)
|
|
|
|
tk->keynames[i] = NULL;
|
|
|
|
|
|
|
|
for(i = 0; i < tk->ncsifuncs; i++)
|
|
|
|
tk->csifuncs[i] = TERMKEY_SYM_NONE;
|
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
// Special built-in names
|
|
|
|
termkey_register_keyname(tk, TERMKEY_SYM_NONE, "NONE");
|
|
|
|
|
2008-02-10 18:46:48 +01:00
|
|
|
termkey_register_c0(tk, TERMKEY_SYM_BACKSPACE, 0x08, "Backspace");
|
|
|
|
termkey_register_c0(tk, TERMKEY_SYM_TAB, 0x09, "Tab");
|
|
|
|
termkey_register_c0(tk, TERMKEY_SYM_ENTER, 0x0a, "Enter");
|
|
|
|
termkey_register_c0(tk, TERMKEY_SYM_ESCAPE, 0x1b, "Escape");
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
// G1
|
|
|
|
termkey_register_keyname(tk, TERMKEY_SYM_SPACE, "Space");
|
|
|
|
termkey_register_keyname(tk, TERMKEY_SYM_DEL, "DEL");
|
|
|
|
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_UP, 'A', "Up");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_DOWN, 'B', "Down");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_RIGHT, 'C', "Right");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_LEFT, 'D', "Left");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_BEGIN, 'E', "Begin");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_END, 'F', "End");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_HOME, 'H', "Home");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_F1, 'P', "F1");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_F2, 'Q', "F2");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_F3, 'R', "F3");
|
|
|
|
termkey_register_csi_ss3(tk, TERMKEY_SYM_F4, 'S', "F4");
|
|
|
|
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPENTER, 'M', "KPEnter", 0);
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPEQUALS, 'X', "KPEquals", '=');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPMULT, 'j', "KPMult", '*');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPPLUS, 'k', "KPPlus", '+');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPCOMMA, 'l', "KPComma", ',');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPMINUS, 'm', "KPMinus", '-');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPPERIOD, 'n', "KPPeriod", '.');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KPDIV, 'o', "KPDiv", '/');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP0, 'p', "KP0", '0');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP1, 'q', "KP1", '1');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP2, 'r', "KP2", '2');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP3, 's', "KP3", '3');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP4, 't', "KP4", '4');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP5, 'u', "KP5", '5');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP6, 'v', "KP6", '6');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP7, 'w', "KP7", '7');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP8, 'x', "KP8", '8');
|
|
|
|
termkey_register_ss3kpalt(tk, TERMKEY_SYM_KP9, 'y', "KP9", '9');
|
|
|
|
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_HOME, 1, "Home");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_INSERT, 2, "Insert");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_DELETE, 3, "Delete");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_END, 4, "End");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_PAGEUP, 5, "PageUp");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_PAGEDOWN, 6, "PageDown");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F5, 15, "F5");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F6, 17, "F6");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F7, 18, "F7");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F8, 19, "F8");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F9, 20, "F9");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F10, 21, "F10");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F11, 23, "F11");
|
|
|
|
termkey_register_csifunc(tk, TERMKEY_SYM_F12, 24, "F12");
|
|
|
|
|
2008-02-07 01:58:41 +01:00
|
|
|
return tk;
|
|
|
|
}
|
|
|
|
|
|
|
|
termkey_t *termkey_new(int fd, int flags)
|
|
|
|
{
|
|
|
|
return termkey_new_full(fd, flags, 256);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void eatbytes(termkey_t *tk, size_t count)
|
|
|
|
{
|
|
|
|
memmove(tk->buffer, tk->buffer + count, tk->buffvalid - count);
|
|
|
|
tk->buffvalid -= count;
|
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
static termkey_result getkey_csi(termkey_t *tk, size_t introlen, termkey_key *key)
|
2008-02-07 01:58:41 +01:00
|
|
|
{
|
|
|
|
size_t csi_end = introlen;
|
|
|
|
|
|
|
|
while(csi_end < tk->buffvalid) {
|
|
|
|
if(tk->buffer[csi_end] >= 0x40 && tk->buffer[csi_end] < 0x80)
|
|
|
|
break;
|
|
|
|
csi_end++;
|
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
if(csi_end >= tk->buffvalid)
|
|
|
|
return TERMKEY_RES_NONE;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
unsigned char cmd = tk->buffer[csi_end];
|
2008-02-07 03:47:15 +01:00
|
|
|
int arg[16];
|
|
|
|
char present = 0;
|
|
|
|
int args = 0;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
size_t p = introlen;
|
|
|
|
|
2008-02-07 03:47:15 +01:00
|
|
|
// Now attempt to parse out up number;number;... separated values
|
|
|
|
while(p < csi_end) {
|
|
|
|
unsigned char c = tk->buffer[p];
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-07 03:47:15 +01:00
|
|
|
if(c >= '0' && c <= '9') {
|
|
|
|
if(!present) {
|
|
|
|
arg[args] = c - '0';
|
|
|
|
present = 1;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
2008-02-07 03:47:15 +01:00
|
|
|
else {
|
|
|
|
arg[args] = (arg[args] * 10) + c - '0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(c == ';') {
|
|
|
|
if(!present)
|
|
|
|
arg[args] = -1;
|
|
|
|
present = 0;
|
|
|
|
args++;
|
|
|
|
|
|
|
|
if(args > 16)
|
|
|
|
break;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
2008-02-07 03:47:15 +01:00
|
|
|
|
|
|
|
p++;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-07 03:47:15 +01:00
|
|
|
if(!present)
|
|
|
|
arg[args] = -1;
|
|
|
|
|
|
|
|
args++;
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
eatbytes(tk, csi_end + 1);
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(cmd == '~') {
|
2008-02-07 03:47:15 +01:00
|
|
|
if(arg[0] >= 0 && arg[0] < tk->ncsifuncs)
|
|
|
|
key->code = tk->csifuncs[arg[0]];
|
2008-02-07 03:21:14 +01:00
|
|
|
else
|
|
|
|
key->code = TERMKEY_SYM_UNKNOWN;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(key->code == TERMKEY_SYM_UNKNOWN)
|
2008-02-07 03:47:15 +01:00
|
|
|
fprintf(stderr, "CSI function key %d\n", arg[0]);
|
2008-02-07 03:21:14 +01:00
|
|
|
}
|
|
|
|
else {
|
2008-02-10 18:34:05 +01:00
|
|
|
// We know from the logic above that cmd must be >= 0x40 and < 0x80
|
|
|
|
key->code = tk->csi_ss3s[cmd - 0x40];
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
if(key->code == TERMKEY_SYM_UNKNOWN)
|
2008-02-07 03:47:15 +01:00
|
|
|
fprintf(stderr, "CSI arg1=%d arg2=%d cmd=%c\n", arg[0], arg[1], cmd);
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-07 03:47:15 +01:00
|
|
|
key->modifiers = (args > 1 && arg[1] != -1) ? arg[1] - 1 : 0;
|
2008-02-07 01:58:41 +01:00
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
static termkey_result getkey_ss3(termkey_t *tk, size_t introlen, termkey_key *key)
|
2008-02-07 01:58:41 +01:00
|
|
|
{
|
2008-02-07 02:17:59 +01:00
|
|
|
if(introlen + 1 < tk->buffvalid)
|
|
|
|
return TERMKEY_RES_NONE;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
unsigned char cmd = tk->buffer[introlen];
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
eatbytes(tk, introlen + 1);
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
if(cmd < 0x40 || cmd >= 0x80)
|
|
|
|
return TERMKEY_SYM_UNKNOWN;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
key->code = tk->csi_ss3s[cmd - 0x40];
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
if(key->code == TERMKEY_SYM_UNKNOWN) {
|
|
|
|
if(tk->flags & TERMKEY_FLAG_CONVERTKP && tk->ss3_kpalts[cmd - 0x40]) {
|
|
|
|
key->code = tk->ss3_kpalts[cmd - 0x40];
|
2008-02-07 03:21:14 +01:00
|
|
|
key->modifiers = 0;
|
2008-02-07 01:58:41 +01:00
|
|
|
key->flags = 0;
|
|
|
|
|
|
|
|
key->utf8[0] = key->code;
|
|
|
|
key->utf8[1] = 0;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
2008-02-07 03:21:14 +01:00
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
key->code = tk->ss3s[cmd - 0x40];
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(key->code == TERMKEY_SYM_UNKNOWN)
|
|
|
|
fprintf(stderr, "SS3 %c (0x%02x)\n", cmd, cmd);
|
|
|
|
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-09 20:30:37 +01:00
|
|
|
#define UTF8_INVALID 0xFFFD
|
|
|
|
|
|
|
|
static int utf8_seqlen(int codepoint)
|
|
|
|
{
|
|
|
|
if(codepoint < 0x0000080) return 1;
|
|
|
|
if(codepoint < 0x0000800) return 2;
|
|
|
|
if(codepoint < 0x0010000) return 3;
|
|
|
|
if(codepoint < 0x0200000) return 4;
|
|
|
|
if(codepoint < 0x4000000) return 5;
|
|
|
|
return 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fill_utf8(termkey_key *key)
|
|
|
|
{
|
|
|
|
int codepoint = key->code;
|
|
|
|
int nbytes = utf8_seqlen(codepoint);
|
|
|
|
|
|
|
|
key->utf8[nbytes] = 0;
|
|
|
|
|
|
|
|
// This is easier done backwards
|
|
|
|
int b = nbytes;
|
2008-02-10 19:12:19 +01:00
|
|
|
while(b > 1) {
|
|
|
|
b--;
|
|
|
|
key->utf8[b] = 0x80 | (codepoint & 0x3f);
|
2008-02-09 20:30:37 +01:00
|
|
|
codepoint >>= 6;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(nbytes) {
|
|
|
|
case 1: key->utf8[0] = (codepoint & 0x7f); break;
|
|
|
|
case 2: key->utf8[0] = 0xc0 | (codepoint & 0x1f); break;
|
|
|
|
case 3: key->utf8[0] = 0xe0 | (codepoint & 0x0f); break;
|
|
|
|
case 4: key->utf8[0] = 0xf0 | (codepoint & 0x07); break;
|
|
|
|
case 5: key->utf8[0] = 0xf8 | (codepoint & 0x03); break;
|
|
|
|
case 6: key->utf8[0] = 0xfc | (codepoint & 0x01); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
termkey_result termkey_getkey(termkey_t *tk, termkey_key *key)
|
2008-02-07 01:58:41 +01:00
|
|
|
{
|
2008-02-07 02:17:59 +01:00
|
|
|
if(tk->buffvalid == 0)
|
|
|
|
return tk->is_closed ? TERMKEY_RES_EOF : TERMKEY_RES_NONE;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
// Now we're sure at least 1 byte is valid
|
|
|
|
unsigned char b0 = tk->buffer[0];
|
|
|
|
|
|
|
|
if(b0 == 0x1b) {
|
|
|
|
if(tk->buffvalid == 1) {
|
|
|
|
key->code = TERMKEY_SYM_ESCAPE;
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char b1 = tk->buffer[1];
|
|
|
|
if(b1 == '[')
|
|
|
|
return getkey_csi(tk, 2, key);
|
|
|
|
|
|
|
|
if(b1 == 'O')
|
|
|
|
return getkey_ss3(tk, 2, key);
|
|
|
|
|
|
|
|
tk->buffer++;
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
termkey_result metakey_result = termkey_getkey(tk, key);
|
|
|
|
|
|
|
|
switch(metakey_result) {
|
|
|
|
case TERMKEY_RES_KEY:
|
|
|
|
key->modifiers |= TERMKEY_KEYMOD_ALT;
|
|
|
|
tk->buffer--;
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TERMKEY_RES_NONE:
|
|
|
|
case TERMKEY_RES_EOF:
|
|
|
|
break;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return metakey_result;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
else if(b0 < 0x20) {
|
|
|
|
// Control key
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
key->code = 0;
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-10 18:46:48 +01:00
|
|
|
if(!(tk->flags & TERMKEY_FLAG_NOINTERPRET) && tk->c0[b0] != TERMKEY_SYM_UNKNOWN)
|
|
|
|
key->code = tk->c0[b0];
|
2008-02-07 01:58:41 +01:00
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
if(!key->code) {
|
2008-02-07 01:58:41 +01:00
|
|
|
key->code = b0 + 0x40;
|
|
|
|
key->modifiers = TERMKEY_KEYMOD_CTRL;
|
|
|
|
key->flags = 0;
|
|
|
|
|
|
|
|
key->utf8[0] = key->code;
|
|
|
|
key->utf8[1] = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
else if(b0 == 0x20 && !(tk->flags & TERMKEY_FLAG_NOINTERPRET)) {
|
|
|
|
key->code = TERMKEY_SYM_SPACE;
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
else if(b0 == 0x7f && !(tk->flags & TERMKEY_FLAG_NOINTERPRET)) {
|
|
|
|
key->code = TERMKEY_SYM_DEL;
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = TERMKEY_KEYFLAG_SPECIAL;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
|
|
|
else if(b0 >= 0x20 && b0 < 0x80) {
|
|
|
|
// ASCII lowbyte range
|
|
|
|
key->code = b0;
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = 0;
|
|
|
|
|
|
|
|
key->utf8[0] = key->code;
|
|
|
|
key->utf8[1] = 0;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-07 01:58:41 +01:00
|
|
|
}
|
2008-02-10 16:28:07 +01:00
|
|
|
else if(b0 == 0x8f) {
|
|
|
|
return getkey_ss3(tk, 1, key);
|
|
|
|
}
|
|
|
|
else if(b0 == 0x9b) {
|
|
|
|
return getkey_csi(tk, 1, key);
|
|
|
|
}
|
2008-02-09 20:30:37 +01:00
|
|
|
else if(b0 >= 0x80 && b0 < 0xa0) {
|
2008-02-10 16:28:07 +01:00
|
|
|
// UTF-8 never starts with a C1 byte. So we can be sure of these
|
|
|
|
key->code = b0 - 0x40;
|
|
|
|
key->modifiers = TERMKEY_KEYMOD_CTRL|TERMKEY_KEYMOD_ALT;
|
|
|
|
key->flags = 0;
|
|
|
|
|
|
|
|
key->utf8[0] = key->code;
|
|
|
|
key->utf8[1] = 0;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
2008-02-09 20:30:37 +01:00
|
|
|
}
|
|
|
|
else if(tk->flags & TERMKEY_FLAG_UTF8) {
|
|
|
|
// Some UTF-8
|
|
|
|
int nbytes;
|
|
|
|
int codepoint;
|
|
|
|
|
|
|
|
key->flags = 0;
|
|
|
|
key->modifiers = 0;
|
|
|
|
|
|
|
|
if(b0 < 0xc0) {
|
|
|
|
// Starts with a continuation byte - that's not right
|
|
|
|
key->code = UTF8_INVALID;
|
|
|
|
|
|
|
|
fill_utf8(key);
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
else if(b0 < 0xe0) {
|
|
|
|
nbytes = 2;
|
|
|
|
codepoint = b0 & 0x1f;
|
|
|
|
}
|
|
|
|
else if(b0 < 0xf0) {
|
|
|
|
nbytes = 3;
|
|
|
|
codepoint = b0 & 0x0f;
|
|
|
|
}
|
|
|
|
else if(b0 < 0xf8) {
|
|
|
|
nbytes = 4;
|
|
|
|
codepoint = b0 & 0x07;
|
|
|
|
}
|
|
|
|
else if(b0 < 0xfc) {
|
|
|
|
nbytes = 5;
|
|
|
|
codepoint = b0 & 0x03;
|
|
|
|
}
|
|
|
|
else if(b0 < 0xfe) {
|
|
|
|
nbytes = 6;
|
|
|
|
codepoint = b0 & 0x01;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
key->code = UTF8_INVALID;
|
|
|
|
|
|
|
|
fill_utf8(key);
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(tk->buffvalid < nbytes)
|
|
|
|
return TERMKEY_RES_NONE;
|
|
|
|
|
|
|
|
for(int b = 1; b < nbytes; b++) {
|
|
|
|
unsigned char cb = tk->buffer[b];
|
|
|
|
if(cb < 0x80 || cb >= 0xc0) {
|
|
|
|
key->code = UTF8_INVALID;
|
|
|
|
|
|
|
|
fill_utf8(key);
|
|
|
|
eatbytes(tk, b - 1);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
codepoint <<= 6;
|
|
|
|
codepoint |= cb & 0x3f;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for overlong sequences
|
|
|
|
if(nbytes > utf8_seqlen(codepoint)) {
|
|
|
|
key->code = UTF8_INVALID;
|
|
|
|
|
|
|
|
fill_utf8(key);
|
|
|
|
eatbytes(tk, nbytes);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for UTF-16 surrogates or invalid codepoints
|
|
|
|
if((codepoint >= 0xD800 && codepoint <= 0xDFFF) ||
|
|
|
|
codepoint == 0xFFFE ||
|
|
|
|
codepoint == 0xFFFF)
|
|
|
|
{
|
|
|
|
key->code = UTF8_INVALID;
|
|
|
|
|
|
|
|
fill_utf8(key);
|
|
|
|
eatbytes(tk, nbytes);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
key->code = codepoint;
|
|
|
|
memcpy(key->utf8, tk->buffer, nbytes);
|
|
|
|
key->utf8[nbytes] = 0;
|
|
|
|
|
|
|
|
eatbytes(tk, nbytes);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Non UTF-8 case - just report the raw byte
|
|
|
|
key->code = b0;
|
|
|
|
key->modifiers = 0;
|
|
|
|
key->flags = 0;
|
|
|
|
|
|
|
|
key->utf8[0] = key->code;
|
|
|
|
key->utf8[1] = 0;
|
|
|
|
|
|
|
|
eatbytes(tk, 1);
|
|
|
|
|
|
|
|
return TERMKEY_RES_KEY;
|
|
|
|
}
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
return TERMKEY_SYM_NONE;
|
|
|
|
}
|
|
|
|
|
2008-02-07 02:17:59 +01:00
|
|
|
termkey_result termkey_waitkey(termkey_t *tk, termkey_key *key)
|
2008-02-07 01:58:41 +01:00
|
|
|
{
|
2008-02-07 02:17:59 +01:00
|
|
|
termkey_result ret;
|
|
|
|
while((ret = termkey_getkey(tk, key)) == TERMKEY_RES_NONE) {
|
2008-02-07 01:58:41 +01:00
|
|
|
termkey_advisereadable(tk);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void termkey_pushinput(termkey_t *tk, unsigned char *input, size_t inputlen)
|
|
|
|
{
|
|
|
|
if(tk->buffvalid + inputlen > tk->buffsize) {
|
|
|
|
fprintf(stderr, "TODO! Extend input buffer!\n");
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Not strcpy just in case of NUL bytes
|
|
|
|
memcpy(tk->buffer + tk->buffvalid, input, inputlen);
|
|
|
|
tk->buffvalid += inputlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
void termkey_advisereadable(termkey_t *tk)
|
|
|
|
{
|
|
|
|
unsigned char buffer[64]; // Smaller than the default size
|
|
|
|
size_t len = read(tk->fd, buffer, sizeof buffer);
|
|
|
|
|
2008-02-09 20:01:49 +01:00
|
|
|
if(len == -1 && errno == EAGAIN)
|
|
|
|
return;
|
|
|
|
else if(len < 1)
|
2008-02-07 01:58:41 +01:00
|
|
|
tk->is_closed = 1;
|
|
|
|
else
|
|
|
|
termkey_pushinput(tk, buffer, len);
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:41:13 +01:00
|
|
|
const char *termkey_describe_sym(termkey_t *tk, termkey_keysym code)
|
2008-02-07 01:58:41 +01:00
|
|
|
{
|
2008-02-07 02:17:59 +01:00
|
|
|
if(code == TERMKEY_SYM_UNKNOWN)
|
2008-02-07 01:58:41 +01:00
|
|
|
return "UNKNOWN";
|
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(code < tk->nkeynames)
|
|
|
|
return tk->keynames[code];
|
2008-02-07 01:58:41 +01:00
|
|
|
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
2008-02-07 03:21:14 +01:00
|
|
|
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym termkey_register_keyname(termkey_t *tk, termkey_keysym code, const char *name)
|
2008-02-07 03:21:14 +01:00
|
|
|
{
|
|
|
|
if(!code)
|
|
|
|
code = tk->nkeynames;
|
|
|
|
|
|
|
|
if(code >= tk->nkeynames) {
|
2008-02-10 18:34:05 +01:00
|
|
|
const char **new_keynames = realloc(tk->keynames, sizeof(new_keynames[0]) * (code + 1));
|
|
|
|
tk->keynames = new_keynames;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
// Fill in the hole
|
|
|
|
for(int i = tk->nkeynames; i < code; i++)
|
|
|
|
tk->keynames[i] = NULL;
|
|
|
|
|
|
|
|
tk->nkeynames = code + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tk->keynames[code] = name;
|
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:46:48 +01:00
|
|
|
termkey_keysym termkey_register_c0(termkey_t *tk, termkey_keysym code, unsigned char ctrl, const char *name)
|
|
|
|
{
|
|
|
|
if(ctrl >= 0x20) {
|
|
|
|
fprintf(stderr, "Cannot register C0 key at ctrl 0x%02x - out of bounds\n", ctrl);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(name)
|
|
|
|
code = termkey_register_keyname(tk, code, name);
|
|
|
|
|
|
|
|
tk->c0[ctrl] = code;
|
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym termkey_register_csi_ss3(termkey_t *tk, termkey_keysym code, unsigned char cmd, const char *name)
|
2008-02-07 03:21:14 +01:00
|
|
|
{
|
2008-02-10 18:34:05 +01:00
|
|
|
if(cmd < 0x40 || cmd >= 0x80) {
|
|
|
|
fprintf(stderr, "Cannot register CSI/SS3 key at cmd 0x%02x - out of bounds\n", cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(name)
|
|
|
|
code = termkey_register_keyname(tk, code, name);
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
tk->csi_ss3s[cmd - 0x40] = code;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym termkey_register_ss3kpalt(termkey_t *tk, termkey_keysym code, unsigned char cmd, const char *name, char kpalt)
|
2008-02-07 03:21:14 +01:00
|
|
|
{
|
2008-02-10 18:34:05 +01:00
|
|
|
if(cmd < 0x40 || cmd >= 0x80) {
|
|
|
|
fprintf(stderr, "Cannot register SS3 key at cmd 0x%02x - out of bounds\n", cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-02-07 03:21:14 +01:00
|
|
|
if(name)
|
|
|
|
code = termkey_register_keyname(tk, code, name);
|
|
|
|
|
2008-02-10 18:34:05 +01:00
|
|
|
tk->ss3s[cmd - 0x40] = code;
|
|
|
|
tk->ss3_kpalts[cmd - 0x40] = kpalt;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym termkey_register_csifunc(termkey_t *tk, termkey_keysym code, int number, const char *name)
|
2008-02-07 03:21:14 +01:00
|
|
|
{
|
|
|
|
if(name)
|
|
|
|
code = termkey_register_keyname(tk, code, name);
|
|
|
|
|
|
|
|
if(number >= tk->ncsifuncs) {
|
2008-02-10 18:41:13 +01:00
|
|
|
termkey_keysym *new_csifuncs = realloc(tk->csifuncs, sizeof(new_csifuncs[0]) * (number + 1));
|
2008-02-10 18:34:05 +01:00
|
|
|
tk->csifuncs = new_csifuncs;
|
2008-02-07 03:21:14 +01:00
|
|
|
|
|
|
|
// Fill in the hole
|
|
|
|
for(int i = tk->ncsifuncs; i < number; i++)
|
|
|
|
tk->csifuncs[i] = TERMKEY_SYM_UNKNOWN;
|
2008-02-10 18:34:05 +01:00
|
|
|
|
|
|
|
tk->ncsifuncs = number + 1;
|
2008-02-07 03:21:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
tk->csifuncs[number] = code;
|
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|