aboutsummaryrefslogtreecommitdiff
path: root/termo.c
diff options
context:
space:
mode:
Diffstat (limited to 'termo.c')
-rw-r--r--termo.c1656
1 files changed, 1656 insertions, 0 deletions
diff --git a/termo.c b/termo.c
new file mode 100644
index 0000000..9f23158
--- /dev/null
+++ b/termo.c
@@ -0,0 +1,1656 @@
+#include "termo.h"
+#include "termo-internal.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <poll.h>
+#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+#include <langinfo.h>
+
+#include <stdio.h>
+
+void
+termo_check_version (int major, int minor)
+{
+ if (major != TERMO_VERSION_MAJOR)
+ fprintf (stderr, "libtermo major version mismatch;"
+ " %d (wants) != %d (library)\n",
+ major, TERMO_VERSION_MAJOR);
+ else if (minor > TERMO_VERSION_MINOR)
+ fprintf (stderr, "libtermo minor version mismatch;"
+ " %d (wants) > %d (library)\n",
+ minor, TERMO_VERSION_MINOR);
+ else
+ return;
+ exit (1);
+}
+
+static termo_driver_t *drivers[] =
+{
+ &termo_driver_ti,
+ &termo_driver_csi,
+ NULL,
+};
+
+// Forwards for the "protected" methods
+static void emit_codepoint (termo_t *tk, uint32_t codepoint, termo_key_t *key);
+static termo_result_t peekkey_simple (termo_t *tk,
+ termo_key_t *key, int force, size_t *nbytes);
+static termo_result_t peekkey_mouse (termo_t *tk,
+ termo_key_t *key, size_t *nbytes);
+
+static termo_sym_t register_c0 (termo_t *tk, termo_sym_t sym,
+ unsigned char ctrl, const char *name);
+static termo_sym_t register_c0_full (termo_t *tk, termo_sym_t sym,
+ int modifier_set, int modifier_mask, unsigned char ctrl, const char *name);
+
+static struct
+{
+ termo_sym_t sym;
+ const char *name;
+}
+keynames[] =
+{
+ { TERMO_SYM_NONE, "NONE" },
+ { TERMO_SYM_BACKSPACE, "Backspace" },
+ { TERMO_SYM_TAB, "Tab" },
+ { TERMO_SYM_ENTER, "Enter" },
+ { TERMO_SYM_ESCAPE, "Escape" },
+ { TERMO_SYM_SPACE, "Space" },
+ { TERMO_SYM_DEL, "DEL" },
+ { TERMO_SYM_UP, "Up" },
+ { TERMO_SYM_DOWN, "Down" },
+ { TERMO_SYM_LEFT, "Left" },
+ { TERMO_SYM_RIGHT, "Right" },
+ { TERMO_SYM_BEGIN, "Begin" },
+ { TERMO_SYM_FIND, "Find" },
+ { TERMO_SYM_INSERT, "Insert" },
+ { TERMO_SYM_DELETE, "Delete" },
+ { TERMO_SYM_SELECT, "Select" },
+ { TERMO_SYM_PAGEUP, "PageUp" },
+ { TERMO_SYM_PAGEDOWN, "PageDown" },
+ { TERMO_SYM_HOME, "Home" },
+ { TERMO_SYM_END, "End" },
+ { TERMO_SYM_CANCEL, "Cancel" },
+ { TERMO_SYM_CLEAR, "Clear" },
+ { TERMO_SYM_CLOSE, "Close" },
+ { TERMO_SYM_COMMAND, "Command" },
+ { TERMO_SYM_COPY, "Copy" },
+ { TERMO_SYM_EXIT, "Exit" },
+ { TERMO_SYM_HELP, "Help" },
+ { TERMO_SYM_MARK, "Mark" },
+ { TERMO_SYM_MESSAGE, "Message" },
+ { TERMO_SYM_MOVE, "Move" },
+ { TERMO_SYM_OPEN, "Open" },
+ { TERMO_SYM_OPTIONS, "Options" },
+ { TERMO_SYM_PRINT, "Print" },
+ { TERMO_SYM_REDO, "Redo" },
+ { TERMO_SYM_REFERENCE, "Reference" },
+ { TERMO_SYM_REFRESH, "Refresh" },
+ { TERMO_SYM_REPLACE, "Replace" },
+ { TERMO_SYM_RESTART, "Restart" },
+ { TERMO_SYM_RESUME, "Resume" },
+ { TERMO_SYM_SAVE, "Save" },
+ { TERMO_SYM_SUSPEND, "Suspend" },
+ { TERMO_SYM_UNDO, "Undo" },
+ { TERMO_SYM_KP0, "KP0" },
+ { TERMO_SYM_KP1, "KP1" },
+ { TERMO_SYM_KP2, "KP2" },
+ { TERMO_SYM_KP3, "KP3" },
+ { TERMO_SYM_KP4, "KP4" },
+ { TERMO_SYM_KP5, "KP5" },
+ { TERMO_SYM_KP6, "KP6" },
+ { TERMO_SYM_KP7, "KP7" },
+ { TERMO_SYM_KP8, "KP8" },
+ { TERMO_SYM_KP9, "KP9" },
+ { TERMO_SYM_KPENTER, "KPEnter" },
+ { TERMO_SYM_KPPLUS, "KPPlus" },
+ { TERMO_SYM_KPMINUS, "KPMinus" },
+ { TERMO_SYM_KPMULT, "KPMult" },
+ { TERMO_SYM_KPDIV, "KPDiv" },
+ { TERMO_SYM_KPCOMMA, "KPComma" },
+ { TERMO_SYM_KPPERIOD, "KPPeriod" },
+ { TERMO_SYM_KPEQUALS, "KPEquals" },
+ { 0, NULL },
+};
+
+#define CHARAT(i) (tk->buffer[tk->buffstart + (i)])
+
+#ifdef DEBUG
+/* Some internal deubgging functions */
+
+static void
+print_buffer (termo_t *tk)
+{
+ size_t i;
+ for (i = 0; i < tk->buffcount && i < 20; i++)
+ fprintf (stderr, "%02x ", CHARAT (i));
+ if (tk->buffcount > 20)
+ fprintf (stderr, "...");
+}
+
+static void
+print_key (termo_t *tk, termo_key_t *key)
+{
+ switch (key->type)
+ {
+ case TERMO_TYPE_KEY:
+ fprintf (stderr, "Unicode codepoint=U+%04lx multibyte='%s'",
+ (long) key->code.codepoint, key->multibyte);
+ break;
+ case TERMO_TYPE_FUNCTION:
+ fprintf (stderr, "Function F%d", key->code.number);
+ break;
+ case TERMO_TYPE_KEYSYM:
+ fprintf (stderr, "Keysym sym=%d(%s)",
+ key->code.sym, termo_get_keyname (tk, key->code.sym));
+ break;
+ case TERMO_TYPE_MOUSE:
+ {
+ termo_mouse_event_t ev;
+ int button, line, col;
+ termo_interpret_mouse (tk, key, &ev, &button, &line, &col);
+ fprintf (stderr, "Mouse ev=%d button=%d pos=(%d,%d)\n",
+ ev, button, line, col);
+ break;
+ }
+ case TERMO_TYPE_POSITION:
+ {
+ int line, col;
+ termo_interpret_position (tk, key, &line, &col);
+ fprintf (stderr, "Position report pos=(%d,%d)\n", line, col);
+ break;
+ }
+ case TERMO_TYPE_MODEREPORT:
+ {
+ int initial, mode, value;
+ termo_interpret_modereport (tk, key, &initial, &mode, &value);
+ fprintf (stderr, "Mode report mode=%s %d val=%d\n",
+ initial == '?' ? "DEC" : "ANSI", mode, value);
+ break;
+ }
+ case TERMO_TYPE_UNKNOWN_CSI:
+ fprintf (stderr, "unknown CSI\n");
+ }
+
+ int m = key->modifiers;
+ fprintf (stderr, " mod=%s%s%s+%02x",
+ (m & TERMO_KEYMOD_CTRL ? "C" : ""),
+ (m & TERMO_KEYMOD_ALT ? "A" : ""),
+ (m & TERMO_KEYMOD_SHIFT ? "S" : ""),
+ m & ~(TERMO_KEYMOD_CTRL | TERMO_KEYMOD_ALT | TERMO_KEYMOD_SHIFT));
+}
+
+static const char *
+res2str (termo_result_t res)
+{
+ static char errorbuffer[256];
+
+ switch (res)
+ {
+ case TERMO_RES_KEY:
+ return "TERMO_RES_KEY";
+ case TERMO_RES_EOF:
+ return "TERMO_RES_EOF";
+ case TERMO_RES_AGAIN:
+ return "TERMO_RES_AGAIN";
+ case TERMO_RES_NONE:
+ return "TERMO_RES_NONE";
+ case TERMO_RES_ERROR:
+ snprintf (errorbuffer, sizeof errorbuffer,
+ "TERMO_RES_ERROR(errno=%d)\n", errno);
+ return (const char*) errorbuffer;
+ }
+
+ return "unknown";
+}
+#endif
+
+/* Similar to snprintf(str, size, "%s", src) except it turns CamelCase into
+ * space separated values
+ */
+static int
+snprint_cameltospaces (char *str, size_t size, const char *src)
+{
+ int prev_lower = 0;
+ size_t l = 0;
+ while (*src && l < size - 1)
+ {
+ if (isupper (*src) && prev_lower)
+ {
+ if (str)
+ str[l++] = ' ';
+ if (l >= size - 1)
+ break;
+ }
+ prev_lower = islower (*src);
+ str[l++] = tolower (*src++);
+ }
+ str[l] = 0;
+
+ /* For consistency with snprintf, return the number of bytes that would have
+ * been written, excluding '\0' */
+ for (; *src; src++)
+ {
+ if (isupper (*src) && prev_lower)
+ l++;
+ prev_lower = islower (*src);
+ l++;
+ }
+ return l;
+}
+
+/* Similar to strcmp(str, strcamel, n) except that:
+ * it compares CamelCase in strcamel with space separated values in str;
+ * it takes char**s and updates them
+ * n counts bytes of strcamel, not str
+ */
+static int
+strpncmp_camel (const char **strp, const char **strcamelp, size_t n)
+{
+ const char *str = *strp, *strcamel = *strcamelp;
+ int prev_lower = 0;
+
+ for (; (*str || *strcamel) && n; n--)
+ {
+ char b = tolower (*strcamel);
+ if (isupper (*strcamel) && prev_lower)
+ {
+ if (*str != ' ')
+ break;
+ str++;
+ if (*str != b)
+ break;
+ }
+ else if (*str != b)
+ break;
+
+ prev_lower = islower (*strcamel);
+
+ str++;
+ strcamel++;
+ }
+
+ *strp = str;
+ *strcamelp = strcamel;
+ return *str - *strcamel;
+}
+
+static termo_t *
+termo_alloc (void)
+{
+ termo_t *tk = malloc (sizeof *tk);
+ if (!tk)
+ return NULL;
+
+ /* Default all the object fields but don't allocate anything */
+
+ tk->fd = -1;
+ tk->flags = 0;
+ tk->canonflags = 0;
+
+ tk->buffer = NULL;
+ tk->buffstart = 0;
+ tk->buffcount = 0;
+ tk->buffsize = 256; /* bytes */
+ tk->hightide = 0;
+
+ tk->restore_termios_valid = false;
+
+ tk->waittime = 50; /* msec */
+
+ tk->is_closed = false;
+ tk->is_started = false;
+
+ tk->nkeynames = 64;
+ tk->keynames = NULL;
+
+ for (int i = 0; i < 32; i++)
+ tk->c0[i].sym = TERMO_SYM_NONE;
+
+ tk->drivers = NULL;
+
+ tk->method.emit_codepoint = &emit_codepoint;
+ tk->method.peekkey_simple = &peekkey_simple;
+ tk->method.peekkey_mouse = &peekkey_mouse;
+ return tk;
+}
+
+static int
+termo_init (termo_t *tk, const char *term, const char *encoding)
+{
+ if (!encoding)
+ encoding = nl_langinfo (CODESET);
+
+ static const uint16_t endianity = 0x0102;
+ const char *utf32 = (*(uint8_t *) &endianity == 0x01)
+ ? "UTF-32BE" : "UTF-32LE";
+
+ if ((tk->to_utf32_conv = iconv_open (utf32, encoding)) == (iconv_t) -1)
+ return 0;
+ if ((tk->from_utf32_conv = iconv_open (encoding, utf32)) == (iconv_t) -1)
+ goto abort_free_to_utf32;
+
+ tk->buffer = malloc (tk->buffsize);
+ if (!tk->buffer)
+ goto abort_free_from_utf32;
+
+ tk->keynames = malloc (sizeof tk->keynames[0] * tk->nkeynames);
+ if (!tk->keynames)
+ goto abort_free_buffer;
+
+ int i;
+ for (i = 0; i < tk->nkeynames; i++)
+ tk->keynames[i] = NULL;
+ for (i = 0; keynames[i].name; i++)
+ if (termo_register_keyname (tk,
+ keynames[i].sym, keynames[i].name) == -1)
+ goto abort_free_keynames;
+
+ register_c0 (tk, TERMO_SYM_BACKSPACE, 0x08, NULL);
+ register_c0 (tk, TERMO_SYM_TAB, 0x09, NULL);
+ register_c0 (tk, TERMO_SYM_ENTER, 0x0d, NULL);
+ register_c0 (tk, TERMO_SYM_ESCAPE, 0x1b, NULL);
+
+ termo_driver_node_t **tail = &tk->drivers;
+ for (i = 0; drivers[i]; i++)
+ {
+ void *info = (*drivers[i]->new_driver) (tk, term);
+ if (!info)
+ continue;
+
+#ifdef DEBUG
+ fprintf (stderr, "Loading the %s driver...\n", drivers[i]->name);
+#endif
+
+ termo_driver_node_t *thisdrv = malloc (sizeof *thisdrv);
+ if (!thisdrv)
+ goto abort_free_drivers;
+
+ thisdrv->driver = drivers[i];
+ thisdrv->info = info;
+ thisdrv->next = NULL;
+
+ *tail = thisdrv;
+ tail = &thisdrv->next;
+
+#ifdef DEBUG
+ fprintf (stderr, "Loaded %s driver\n", drivers[i]->name);
+#endif
+ }
+
+ if (!tk->drivers)
+ {
+ errno = ENOENT;
+ goto abort_free_keynames;
+ }
+ return 1;
+
+abort_free_drivers:
+ for (termo_driver_node_t *p = tk->drivers; p; )
+ {
+ (*p->driver->free_driver) (p->info);
+ termo_driver_node_t *next = p->next;
+ free (p);
+ p = next;
+ }
+
+abort_free_keynames:
+ free (tk->keynames);
+abort_free_buffer:
+ free (tk->buffer);
+abort_free_from_utf32:
+ iconv_close (tk->from_utf32_conv);
+abort_free_to_utf32:
+ iconv_close (tk->to_utf32_conv);
+ return 0;
+}
+
+termo_t *
+termo_new (int fd, const char *encoding, int flags)
+{
+ termo_t *tk = termo_alloc ();
+ if (!tk)
+ return NULL;
+
+ tk->fd = fd;
+ termo_set_flags (tk, flags);
+
+ const char *term = getenv ("TERM");
+ if (termo_init (tk, term, encoding)
+ && termo_start (tk))
+ return tk;
+
+ free (tk);
+ return NULL;
+}
+
+termo_t *
+termo_new_abstract (const char *term, const char *encoding, int flags)
+{
+ termo_t *tk = termo_alloc ();
+ if (!tk)
+ return NULL;
+
+ tk->fd = -1;
+ termo_set_flags (tk, flags);
+
+ if (!termo_init (tk, term, encoding))
+ {
+ free (tk);
+ return NULL;
+ }
+
+ termo_start (tk);
+ return tk;
+}
+
+void
+termo_free (termo_t *tk)
+{
+ free (tk->buffer); tk->buffer = NULL;
+ free (tk->keynames); tk->keynames = NULL;
+
+ iconv_close (tk->to_utf32_conv);
+ tk->to_utf32_conv = (iconv_t) -1;
+ iconv_close (tk->from_utf32_conv);
+ tk->from_utf32_conv = (iconv_t) -1;
+
+ termo_driver_node_t *p, *next;
+ for (p = tk->drivers; p; p = next)
+ {
+ (*p->driver->free_driver) (p->info);
+ next = p->next;
+ free (p);
+ }
+ free (tk);
+}
+
+void
+termo_destroy (termo_t *tk)
+{
+ if (tk->is_started)
+ termo_stop (tk);
+
+ termo_free (tk);
+}
+
+int
+termo_start (termo_t *tk)
+{
+ if (tk->is_started)
+ return 1;
+
+ if (tk->fd != -1 && !(tk->flags & TERMO_FLAG_NOTERMIOS))
+ {
+ struct termios termios;
+ if (tcgetattr (tk->fd, &termios) == 0)
+ {
+ tk->restore_termios = termios;
+ tk->restore_termios_valid = true;
+
+ termios.c_iflag &= ~(IXON|INLCR|ICRNL);
+ termios.c_lflag &= ~(ICANON|ECHO);
+ termios.c_cc[VMIN] = 1;
+ termios.c_cc[VTIME] = 0;
+
+ if (tk->flags & TERMO_FLAG_CTRLC)
+ /* want no signal keys at all, so just disable ISIG */
+ termios.c_lflag &= ~ISIG;
+ else
+ {
+ /* Disable ^\ == VQUIT and ^D == VSUSP but leave ^C as SIGINT */
+ termios.c_cc[VQUIT] = _POSIX_VDISABLE;
+ termios.c_cc[VSUSP] = _POSIX_VDISABLE;
+ /* Some OSes have ^Y == VDSUSP */
+#ifdef VDSUSP
+ termios.c_cc[VDSUSP] = _POSIX_VDISABLE;
+#endif
+ }
+
+#ifdef DEBUG
+ fprintf (stderr, "Setting termios(3) flags\n");
+#endif
+ tcsetattr (tk->fd, TCSANOW, &termios);
+ }
+ }
+
+ termo_driver_node_t *p;
+ for (p = tk->drivers; p; p = p->next)
+ if (p->driver->start_driver)
+ if (!(*p->driver->start_driver) (tk, p->info))
+ return 0;
+
+#ifdef DEBUG
+ fprintf (stderr, "Drivers started; termo instance %p is ready\n", tk);
+#endif
+
+ tk->is_started = 1;
+ return 1;
+}
+
+int
+termo_stop (termo_t *tk)
+{
+ if (!tk->is_started)
+ return 1;
+
+ struct termo_driver_node *p;
+ for (p = tk->drivers; p; p = p->next)
+ if (p->driver->stop_driver)
+ (*p->driver->stop_driver) (tk, p->info);
+
+ if (tk->restore_termios_valid)
+ tcsetattr (tk->fd, TCSANOW, &tk->restore_termios);
+
+ tk->is_started = false;
+ return 1;
+}
+
+int
+termo_is_started (termo_t *tk)
+{
+ return tk->is_started;
+}
+
+int
+termo_get_fd (termo_t *tk)
+{
+ return tk->fd;
+}
+
+int
+termo_get_flags (termo_t *tk)
+{
+ return tk->flags;
+}
+
+void
+termo_set_flags (termo_t *tk, int newflags)
+{
+ tk->flags = newflags;
+ if (tk->flags & TERMO_FLAG_SPACESYMBOL)
+ tk->canonflags |= TERMO_CANON_SPACESYMBOL;
+ else
+ tk->canonflags &= ~TERMO_CANON_SPACESYMBOL;
+}
+
+void
+termo_set_waittime (termo_t *tk, int msec)
+{
+ tk->waittime = msec;
+}
+
+int
+termo_get_waittime (termo_t *tk)
+{
+ return tk->waittime;
+}
+
+int
+termo_get_canonflags (termo_t *tk)
+{
+ return tk->canonflags;
+}
+
+void
+termo_set_canonflags (termo_t *tk, int flags)
+{
+ tk->canonflags = flags;
+ if (tk->canonflags & TERMO_CANON_SPACESYMBOL)
+ tk->flags |= TERMO_FLAG_SPACESYMBOL;
+ else
+ tk->flags &= ~TERMO_FLAG_SPACESYMBOL;
+}
+
+size_t
+termo_get_buffer_size (termo_t *tk)
+{
+ return tk->buffsize;
+}
+
+int
+termo_set_buffer_size (termo_t *tk, size_t size)
+{
+ unsigned char *buffer = realloc (tk->buffer, size);
+ if (!buffer)
+ return 0;
+
+ tk->buffer = buffer;
+ tk->buffsize = size;
+ return 1;
+}
+
+size_t
+termo_get_buffer_remaining (termo_t *tk)
+{
+ /* Return the total number of free bytes in the buffer,
+ * because that's what is available to the user. */
+ return tk->buffsize - tk->buffcount;
+}
+
+static void
+eat_bytes (termo_t *tk, size_t count)
+{
+ if (count >= tk->buffcount)
+ {
+ tk->buffstart = 0;
+ tk->buffcount = 0;
+ return;
+ }
+
+ tk->buffstart += count;
+ tk->buffcount -= count;
+}
+
+#define MULTIBYTE_INVALID '?'
+
+static void
+fill_multibyte (termo_t *tk, termo_key_t *key)
+{
+ size_t codepoint_len = sizeof key->code.codepoint;
+ char *codepoint_ptr = (char *) &key->code.codepoint;
+ size_t multibyte_len = sizeof key->multibyte;
+ char *multibyte_ptr = (char *) key->multibyte;
+
+ size_t result = iconv (tk->from_utf32_conv,
+ &codepoint_ptr, &codepoint_len, &multibyte_ptr, &multibyte_len);
+ size_t output = sizeof key->multibyte - multibyte_len;
+
+ // Something broke
+ if (result == (size_t) -1 || output == 0)
+ {
+ key->multibyte[0] = MULTIBYTE_INVALID;
+ key->multibyte[1] = 0;
+ return;
+ }
+
+ // Append a null character, as it wasn't port of the input
+ key->multibyte[output] = 0;
+}
+
+static termo_result_t
+parse_multibyte (termo_t *tk, const unsigned char *bytes, size_t len,
+ uint32_t *cp, size_t *nbytep)
+{
+ size_t multibyte_len = len;
+ char *multibyte_ptr = (char *) bytes;
+ size_t codepoint_len = sizeof *cp;
+ char *codepoint_ptr = (char *) cp;
+
+ // Fingers crossed...
+ errno = 0;
+ iconv (tk->to_utf32_conv,
+ &multibyte_ptr, &multibyte_len, &codepoint_ptr, &codepoint_len);
+
+ // Only one Unicode character could have been processed at maximum,
+ // so let's just set the number of processed bytes to the difference
+ *nbytep = len - multibyte_len;
+
+ // Nothing has been converted, let's examine what happened
+ if (codepoint_ptr == (char *) cp)
+ {
+ if (errno == 0)
+ // The input was probably a shift sequence
+ return TERMO_RES_AGAIN;
+ if (errno == EINVAL)
+ // Incomplete character or shift sequence
+ return TERMO_RES_AGAIN;
+ if (errno == EILSEQ)
+ {
+ // Invalid multibyte sequence in the input, let's try going
+ // byte after byte in hope we skip it completely
+ *cp = MULTIBYTE_INVALID;
+ *nbytep = 1;
+ return TERMO_RES_KEY;
+ }
+
+ // We can't really get E2BIG so what the fuck is going on here
+ abort ();
+ }
+ return TERMO_RES_KEY;
+}
+
+static void
+emit_codepoint (termo_t *tk, uint32_t codepoint, termo_key_t *key)
+{
+ if (codepoint < 0x20)
+ {
+ // C0 range
+ key->code.codepoint = 0;
+ key->modifiers = 0;
+
+ if (!(tk->flags & TERMO_FLAG_NOINTERPRET)
+ && tk->c0[codepoint].sym != TERMO_SYM_UNKNOWN)
+ {
+ key->code.sym = tk->c0[codepoint].sym;
+ key->modifiers |= tk->c0[codepoint].modifier_set;
+ }
+
+ if (!key->code.sym)
+ {
+ key->type = TERMO_TYPE_KEY;
+ /* Generically modified Unicode ought not report the SHIFT state,
+ * or else we get into complications trying to report Shift-; vs :
+ * and so on... In order to be able to represent Ctrl-Shift-A as
+ * CTRL modified unicode A, we need to call Ctrl-A simply 'a',
+ * lowercase
+ */
+ if (codepoint + 0x40 >= 'A' && codepoint + 0x40 <= 'Z')
+ // It's a letter - use lowercase instead
+ key->code.codepoint = codepoint + 0x60;
+ else
+ key->code.codepoint = codepoint + 0x40;
+ key->modifiers = TERMO_KEYMOD_CTRL;
+ }
+ else
+ key->type = TERMO_TYPE_KEYSYM;
+ }
+ else if (codepoint == 0x7f && !(tk->flags & TERMO_FLAG_NOINTERPRET))
+ {
+ // ASCII DEL
+ key->type = TERMO_TYPE_KEYSYM;
+ key->code.sym = TERMO_SYM_DEL;
+ key->modifiers = 0;
+ }
+ else
+ {
+ key->type = TERMO_TYPE_KEY;
+ key->code.codepoint = codepoint;
+ key->modifiers = 0;
+ }
+
+ termo_canonicalise (tk, key);
+
+ if (key->type == TERMO_TYPE_KEY)
+ fill_multibyte (tk, key);
+}
+
+void
+termo_canonicalise (termo_t *tk, termo_key_t *key)
+{
+ int flags = tk->canonflags;
+
+ if (flags & TERMO_CANON_SPACESYMBOL)
+ {
+ if (key->type == TERMO_TYPE_KEY && key->code.codepoint == 0x20)
+ {
+ key->type = TERMO_TYPE_KEYSYM;
+ key->code.sym = TERMO_SYM_SPACE;
+ }
+ }
+ else
+ {
+ if (key->type == TERMO_TYPE_KEYSYM
+ && key->code.sym == TERMO_SYM_SPACE)
+ {
+ key->type = TERMO_TYPE_KEY;
+ key->code.codepoint = 0x20;
+ fill_multibyte (tk, key);
+ }
+ }
+
+ if (flags & TERMO_CANON_DELBS)
+ if (key->type == TERMO_TYPE_KEYSYM
+ && key->code.sym == TERMO_SYM_DEL)
+ key->code.sym = TERMO_SYM_BACKSPACE;
+}
+
+static termo_result_t
+peekkey (termo_t *tk, termo_key_t *key, int force, size_t *nbytep)
+{
+ int again = 0;
+
+ if (!tk->is_started)
+ {
+ errno = EINVAL;
+ return TERMO_RES_ERROR;
+ }
+
+#ifdef DEBUG
+ fprintf (stderr, "getkey(force=%d): buffer ", force);
+ print_buffer (tk);
+ fprintf (stderr, "\n");
+#endif
+
+ if (tk->hightide)
+ {
+ tk->buffstart += tk->hightide;
+ tk->buffcount -= tk->hightide;
+ tk->hightide = 0;
+ }
+
+ termo_result_t ret;
+ termo_driver_node_t *p;
+ for (p = tk->drivers; p; p = p->next)
+ {
+ ret = (p->driver->peekkey) (tk, p->info, key, force, nbytep);
+
+#ifdef DEBUG
+ fprintf (stderr, "Driver %s yields %s\n",
+ p->driver->name, res2str (ret));
+#endif
+
+ switch (ret)
+ {
+ case TERMO_RES_KEY:
+ {
+#ifdef DEBUG
+ print_key (tk, key); fprintf (stderr, "\n");
+#endif
+ // Slide the data down to stop it running away
+ size_t halfsize = tk->buffsize / 2;
+ if (tk->buffstart > halfsize)
+ {
+ memcpy (tk->buffer, tk->buffer + halfsize, halfsize);
+ tk->buffstart -= halfsize;
+ }
+
+ /* fallthrough */
+ }
+ case TERMO_RES_EOF:
+ case TERMO_RES_ERROR:
+ return ret;
+
+ case TERMO_RES_AGAIN:
+ if (!force)
+ again = 1;
+ case TERMO_RES_NONE:
+ break;
+ }
+ }
+
+ if (again)
+ return TERMO_RES_AGAIN;
+
+ ret = peekkey_simple (tk, key, force, nbytep);
+
+#ifdef DEBUG
+ fprintf (stderr, "getkey_simple(force=%d) yields %s\n",
+ force, res2str (ret));
+ if (ret == TERMO_RES_KEY)
+ {
+ print_key (tk, key);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+ return ret;
+}
+
+static termo_result_t
+peekkey_simple (termo_t *tk, termo_key_t *key, int force, size_t *nbytep)
+{
+ if (tk->buffcount == 0)
+ return tk->is_closed ? TERMO_RES_EOF : TERMO_RES_NONE;
+
+ unsigned char b0 = CHARAT (0);
+ if (b0 == 0x1b)
+ {
+ // Escape-prefixed value? Might therefore be Alt+key
+ if (tk->buffcount == 1)
+ {
+ // This might be an <Esc> press, or it may want to be part
+ // of a longer sequence
+ if (!force)
+ return TERMO_RES_AGAIN;
+
+ (*tk->method.emit_codepoint) (tk, b0, key);
+ *nbytep = 1;
+ return TERMO_RES_KEY;
+ }
+
+ // Try another key there
+ tk->buffstart++;
+ tk->buffcount--;
+
+ // Run the full driver
+ termo_result_t metakey_result = peekkey (tk, key, force, nbytep);
+
+ tk->buffstart--;
+ tk->buffcount++;
+
+ switch (metakey_result)
+ {
+ case TERMO_RES_KEY:
+ key->modifiers |= TERMO_KEYMOD_ALT;
+ (*nbytep)++;
+ break;
+
+ case TERMO_RES_NONE:
+ case TERMO_RES_EOF:
+ case TERMO_RES_AGAIN:
+ case TERMO_RES_ERROR:
+ break;
+ }
+
+ return metakey_result;
+ }
+ else if (!(tk->flags & TERMO_FLAG_RAW))
+ {
+ uint32_t codepoint;
+ termo_result_t res = parse_multibyte
+ (tk, tk->buffer + tk->buffstart, tk->buffcount, &codepoint, nbytep);
+
+ if (res == TERMO_RES_AGAIN && force)
+ {
+ /* There weren't enough bytes for a complete character but
+ * caller demands an answer. About the best thing we can do here
+ * is eat as many bytes as we have, and emit a MULTIBYTE_INVALID.
+ * If the remaining bytes arrive later, they'll be invalid too.
+ */
+ codepoint = MULTIBYTE_INVALID;
+ *nbytep = tk->buffcount;
+ res = TERMO_RES_KEY;
+ }
+
+ key->type = TERMO_TYPE_KEY;
+ key->modifiers = 0;
+ (*tk->method.emit_codepoint) (tk, codepoint, key);
+ return res;
+ }
+ else
+ {
+ // Non multibyte case - just report the raw byte
+ key->type = TERMO_TYPE_KEY;
+ key->code.codepoint = b0;
+ key->modifiers = 0;
+
+ key->multibyte[0] = b0;
+ key->multibyte[1] = 0;
+
+ *nbytep = 1;
+ return TERMO_RES_KEY;
+ }
+}
+
+// XXX: With the current infrastructure I'm not sure how to properly handle
+// this. peekkey() isn't made for skipping invalid inputs.
+#define INVALID_1005 0x20
+
+static termo_result_t
+parse_1005_value (const unsigned char **bytes, size_t *len, uint32_t *cp)
+{
+ unsigned int nbytes;
+ unsigned char b0 = (*bytes)[0];
+ if (b0 < 0x80)
+ {
+ // Single byte ASCII
+ *cp = b0;
+ nbytes = 1;
+ goto end;
+ }
+ else if (b0 < 0xc0)
+ {
+ // Starts with a continuation byte - that's not right
+ *cp = INVALID_1005;
+ nbytes = 1;
+ goto end;
+ }
+ else if (b0 < 0xe0)
+ {
+ nbytes = 2;
+ *cp = b0 & 0x1f;
+ }
+ else if (b0 < 0xf0)
+ {
+ nbytes = 3;
+ *cp = b0 & 0x0f;
+ }
+ else if (b0 < 0xf8)
+ {
+ nbytes = 4;
+ *cp = b0 & 0x07;
+ }
+ else if (b0 < 0xfc)
+ {
+ nbytes = 5;
+ *cp = b0 & 0x03;
+ }
+ else if (b0 < 0xfe)
+ {
+ nbytes = 6;
+ *cp = b0 & 0x01;
+ }
+ else
+ {
+ *cp = INVALID_1005;
+ nbytes = 1;
+ goto end;
+ }
+
+ for (unsigned int b = 1; b < nbytes; b++)
+ {
+ if (b >= *len)
+ return TERMO_RES_AGAIN;
+
+ unsigned char cb = (*bytes)[b];
+ if (cb < 0x80 || cb >= 0xc0)
+ {
+ *cp = INVALID_1005;
+ nbytes = b;
+ goto end;
+ }
+ *cp <<= 6;
+ *cp |= cb & 0x3f;
+ }
+
+end:
+ (*bytes) += nbytes;
+ (*len) -= nbytes;
+ return TERMO_RES_KEY;
+}
+
+static termo_result_t
+peekkey_mouse (termo_t *tk, termo_key_t *key, size_t *nbytep)
+{
+ uint32_t b, x, y;
+
+ // TODO: Add some API to switch on 1005 mode support
+ if (false)
+ {
+ const unsigned char *buff = tk->buffer + tk->buffstart;
+ size_t len = tk->buffcount;
+
+ if (parse_1005_value (&buff, &len, &b) == TERMO_RES_AGAIN
+ || parse_1005_value (&buff, &len, &x) == TERMO_RES_AGAIN
+ || parse_1005_value (&buff, &len, &y) == TERMO_RES_AGAIN)
+ return TERMO_RES_AGAIN;
+
+ *nbytep = tk->buffcount - len;
+ }
+ else
+ {
+ if (tk->buffcount < 3)
+ return TERMO_RES_AGAIN;
+
+ b = CHARAT (0);
+ x = CHARAT (1);
+ y = CHARAT (2);
+
+ *nbytep = 3;
+ }
+
+ key->type = TERMO_TYPE_MOUSE;
+ key->code.mouse.info = b - 0x20;
+ key->code.mouse.x = x - 0x20 - 1;
+ key->code.mouse.y = y - 0x20 - 1;
+
+ key->modifiers = (key->code.mouse.info & 0x1c) >> 2;
+ key->code.mouse.info &= ~0x1c;
+
+ return TERMO_RES_KEY;
+}
+
+termo_result_t
+termo_getkey (termo_t *tk, termo_key_t *key)
+{
+ size_t nbytes = 0;
+ termo_result_t ret = peekkey (tk, key, 0, &nbytes);
+
+ if (ret == TERMO_RES_KEY)
+ eat_bytes (tk, nbytes);
+
+ if (ret == TERMO_RES_AGAIN)
+ /* Call peekkey() again in force mode to obtain whatever it can */
+ (void) peekkey (tk, key, 1, &nbytes);
+ /* Don't eat it yet though */
+
+ return ret;
+}
+
+termo_result_t
+termo_getkey_force (termo_t *tk, termo_key_t *key)
+{
+ size_t nbytes = 0;
+ termo_result_t ret = peekkey (tk, key, 1, &nbytes);
+
+ if (ret == TERMO_RES_KEY)
+ eat_bytes (tk, nbytes);
+
+ return ret;
+}
+
+termo_result_t
+termo_waitkey (termo_t *tk, termo_key_t *key)
+{
+ if (tk->fd == -1)
+ {
+ errno = EBADF;
+ return TERMO_RES_ERROR;
+ }
+
+ while (1)
+ {
+ termo_result_t ret = termo_getkey (tk, key);
+
+ switch (ret)
+ {
+ case TERMO_RES_KEY:
+ case TERMO_RES_EOF:
+ case TERMO_RES_ERROR:
+ return ret;
+
+ case TERMO_RES_NONE:
+ ret = termo_advisereadable (tk);
+ if (ret == TERMO_RES_ERROR)
+ return ret;
+ break;
+
+ case TERMO_RES_AGAIN:
+ {
+ if (tk->is_closed)
+ // We're closed now. Never going to get more bytes
+ // so just go with what we have
+ return termo_getkey_force (tk, key);
+
+ struct pollfd fd;
+retry:
+ fd.fd = tk->fd;
+ fd.events = POLLIN;
+
+ int pollret = poll (&fd, 1, tk->waittime);
+ if (pollret == -1)
+ {
+ if (errno == EINTR && !(tk->flags & TERMO_FLAG_EINTR))
+ goto retry;
+
+ return TERMO_RES_ERROR;
+ }
+
+ if (fd.revents & (POLLIN | POLLHUP | POLLERR))
+ ret = termo_advisereadable (tk);
+ else
+ ret = TERMO_RES_NONE;
+
+ if (ret == TERMO_RES_ERROR)
+ return ret;
+ if (ret == TERMO_RES_NONE)
+ return termo_getkey_force (tk, key);
+ }
+ }
+ }
+
+ /* UNREACHABLE */
+}
+
+termo_result_t
+termo_advisereadable (termo_t *tk)
+{
+ if (tk->fd == -1)
+ {
+ errno = EBADF;
+ return TERMO_RES_ERROR;
+ }
+
+ if (tk->buffstart)
+ {
+ memmove (tk->buffer, tk->buffer + tk->buffstart, tk->buffcount);
+ tk->buffstart = 0;
+ }
+
+ /* Not expecting it ever to be greater but doesn't hurt to handle that */
+ if (tk->buffcount >= tk->buffsize)
+ {
+ errno = ENOMEM;
+ return TERMO_RES_ERROR;
+ }
+
+ ssize_t len;
+retry:
+ len = read (tk->fd, tk->buffer + tk->buffcount,
+ tk->buffsize - tk->buffcount);
+
+ if (len == -1)
+ {
+ if (errno == EAGAIN)
+ return TERMO_RES_NONE;
+ if (errno == EINTR && !(tk->flags & TERMO_FLAG_EINTR))
+ goto retry;
+ return TERMO_RES_ERROR;
+ }
+ if (len < 1)
+ {
+ tk->is_closed = true;
+ return TERMO_RES_NONE;
+ }
+ tk->buffcount += len;
+ return TERMO_RES_AGAIN;
+}
+
+size_t
+termo_push_bytes (termo_t *tk, const char *bytes, size_t len)
+{
+ if (tk->buffstart)
+ {
+ memmove (tk->buffer, tk->buffer + tk->buffstart, tk->buffcount);
+ tk->buffstart = 0;
+ }
+
+ /* Not expecting it ever to be greater but doesn't hurt to handle that */
+ if (tk->buffcount >= tk->buffsize)
+ {
+ errno = ENOMEM;
+ return (size_t)-1;
+ }
+
+ if (len > tk->buffsize - tk->buffcount)
+ len = tk->buffsize - tk->buffcount;
+
+ // memcpy(), not strncpy() in case of null bytes in input
+ memcpy (tk->buffer + tk->buffcount, bytes, len);
+ tk->buffcount += len;
+
+ return len;
+}
+
+termo_sym_t
+termo_register_keyname (termo_t *tk, termo_sym_t sym, const char *name)
+{
+ if (!sym)
+ sym = tk->nkeynames;
+
+ if (sym >= tk->nkeynames)
+ {
+ const char **new_keynames =
+ realloc (tk->keynames, sizeof new_keynames[0] * (sym + 1));
+ if (!new_keynames)
+ return -1;
+
+ tk->keynames = new_keynames;
+
+ // Fill in the hole
+ for (int i = tk->nkeynames; i < sym; i++)
+ tk->keynames[i] = NULL;
+
+ tk->nkeynames = sym + 1;
+ }
+
+ tk->keynames[sym] = name;
+ return sym;
+}
+
+const char *
+termo_get_keyname (termo_t *tk, termo_sym_t sym)
+{
+ if (sym == TERMO_SYM_UNKNOWN)
+ return "UNKNOWN";
+ if (sym < tk->nkeynames)
+ return tk->keynames[sym];
+ return "UNKNOWN";
+}
+
+static const char *
+termo_lookup_keyname_format (termo_t *tk,
+ const char *str, termo_sym_t *sym, termo_format_t format)
+{
+ /* We store an array, so we can't do better than a linear search. Doesn't
+ * matter because user won't be calling this too often */
+
+ for (*sym = 0; *sym < tk->nkeynames; (*sym)++)
+ {
+ const char *thiskey = tk->keynames[*sym];
+ if (!thiskey)
+ continue;
+ size_t len = strlen (thiskey);
+ if (format & TERMO_FORMAT_LOWERSPACE)
+ {
+ const char *thisstr = str;
+ if (strpncmp_camel (&thisstr, &thiskey, len) == 0)
+ return thisstr;
+ }
+ else if (!strncmp (str, thiskey, len))
+ return (char *) str + len;
+ }
+ return NULL;
+}
+
+const char *
+termo_lookup_keyname (termo_t *tk, const char *str, termo_sym_t *sym)
+{
+ return termo_lookup_keyname_format (tk, str, sym, 0);
+}
+
+termo_sym_t
+termo_keyname2sym (termo_t *tk, const char *keyname)
+{
+ termo_sym_t sym;
+ const char *endp = termo_lookup_keyname (tk, keyname, &sym);
+ if (!endp || endp[0])
+ return TERMO_SYM_UNKNOWN;
+ return sym;
+}
+
+static termo_sym_t
+register_c0 (termo_t *tk,
+ termo_sym_t sym, unsigned char ctrl, const char *name)
+{
+ return register_c0_full (tk, sym, 0, 0, ctrl, name);
+}
+
+static termo_sym_t
+register_c0_full (termo_t *tk, termo_sym_t sym,
+ int modifier_set, int modifier_mask, unsigned char ctrl, const char *name)
+{
+ if (ctrl >= 0x20)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (name)
+ sym = termo_register_keyname (tk, sym, name);
+
+ tk->c0[ctrl].sym = sym;
+ tk->c0[ctrl].modifier_set = modifier_set;
+ tk->c0[ctrl].modifier_mask = modifier_mask;
+ return sym;
+}
+
+static struct modnames
+{
+ const char *shift, *alt, *ctrl;
+}
+modnames[] =
+{
+ { "S", "A", "C" }, // 0
+ { "Shift", "Alt", "Ctrl" }, // LONGMOD
+ { "S", "M", "C" }, // ALTISMETA
+ { "Shift", "Meta", "Ctrl" }, // ALTISMETA+LONGMOD
+ { "s", "a", "c" }, // LOWERMOD
+ { "shift", "alt", "ctrl" }, // LOWERMOD+LONGMOD
+ { "s", "m", "c" }, // LOWERMOD+ALTISMETA
+ { "shift", "meta", "ctrl" }, // LOWERMOD+ALTISMETA+LONGMOD
+};
+
+size_t
+termo_strfkey (termo_t *tk, char *buffer, size_t len,
+ termo_key_t *key, termo_format_t format)
+{
+ size_t pos = 0;
+ size_t l = 0;
+
+ struct modnames *mods = &modnames[
+ !!(format & TERMO_FORMAT_LONGMOD) +
+ !!(format & TERMO_FORMAT_ALTISMETA) * 2 +
+ !!(format & TERMO_FORMAT_LOWERMOD) * 4];
+
+ int wrapbracket = (format & TERMO_FORMAT_WRAPBRACKET) &&
+ (key->type != TERMO_TYPE_KEY || key->modifiers != 0);
+
+ char sep = (format & TERMO_FORMAT_SPACEMOD) ? ' ' : '-';
+
+ if (format & TERMO_FORMAT_CARETCTRL &&
+ key->type == TERMO_TYPE_KEY &&
+ key->modifiers == TERMO_KEYMOD_CTRL)
+ {
+ uint32_t codepoint = key->code.codepoint;
+
+ // Handle some of the special casesfirst
+ if (codepoint >= 'a' && codepoint <= 'z')
+ {
+ l = snprintf (buffer + pos, len - pos,
+ wrapbracket ? "<^%c>" : "^%c", (char) codepoint - 0x20);
+ if (l <= 0)
+ return pos;
+ pos += l;
+ return pos;
+ }
+ else if ((codepoint >= '@' && codepoint < 'A') ||
+ (codepoint > 'Z' && codepoint <= '_'))
+ {
+ l = snprintf (buffer + pos, len - pos,
+ wrapbracket ? "<^%c>" : "^%c", (char) codepoint);
+ if(l <= 0)
+ return pos;
+ pos += l;
+ return pos;
+ }
+ }
+
+ if (wrapbracket)
+ {
+ l = snprintf (buffer + pos, len - pos, "<");
+ if (l <= 0)
+ return pos;
+ pos += l;
+ }
+
+ if (key->modifiers & TERMO_KEYMOD_ALT)
+ {
+ l = snprintf (buffer + pos, len - pos, "%s%c", mods->alt, sep);
+ if (l <= 0)
+ return pos;
+ pos += l;
+ }
+ if (key->modifiers & TERMO_KEYMOD_CTRL)
+ {
+ l = snprintf (buffer + pos, len - pos, "%s%c", mods->ctrl, sep);
+ if (l <= 0)
+ return pos;
+ pos += l;
+ }
+ if (key->modifiers & TERMO_KEYMOD_SHIFT)
+ {
+ l = snprintf (buffer + pos, len - pos, "%s%c", mods->shift, sep);
+ if (l <= 0)
+ return pos;
+ pos += l;
+ }
+
+ switch (key->type)
+ {
+ case TERMO_TYPE_KEY:
+ if (!key->multibyte[0]) // In case of user-supplied key structures
+ fill_multibyte (tk, key);
+ l = snprintf (buffer + pos, len - pos, "%s", key->multibyte);
+ break;
+ case TERMO_TYPE_KEYSYM:
+ {
+ const char *name = termo_get_keyname (tk, key->code.sym);
+ if (format & TERMO_FORMAT_LOWERSPACE)
+ l = snprint_cameltospaces (buffer + pos, len - pos, name);
+ else
+ l = snprintf (buffer + pos, len - pos, "%s", name);
+ break;
+ }
+ case TERMO_TYPE_FUNCTION:
+ l = snprintf (buffer + pos, len - pos, "%c%d",
+ (format & TERMO_FORMAT_LOWERSPACE ? 'f' : 'F'), key->code.number);
+ break;
+ case TERMO_TYPE_MOUSE:
+ {
+ termo_mouse_event_t ev;
+ int button;
+ int line, col;
+ termo_interpret_mouse (tk, key, &ev, &button, &line, &col);
+
+ static const char *evnames[] =
+ { "Unknown", "Press", "Drag", "Release" };
+ l = snprintf (buffer + pos, len - pos,
+ "Mouse%s(%d)", evnames[ev], button);
+ if (format & TERMO_FORMAT_MOUSE_POS)
+ {
+ if (l <= 0)
+ return pos;
+ pos += l;
+ l = snprintf (buffer + pos, len - pos, " @ (%u,%u)", col, line);
+ }
+ break;
+ }
+ case TERMO_TYPE_POSITION:
+ l = snprintf (buffer + pos, len - pos, "Position");
+ break;
+ case TERMO_TYPE_MODEREPORT:
+ {
+ int initial, mode, value;
+ termo_interpret_modereport (tk, key, &initial, &mode, &value);
+ if (initial)
+ l = snprintf (buffer + pos, len - pos,
+ "Mode(%c%d=%d)", initial, mode, value);
+ else
+ l = snprintf (buffer + pos, len - pos,
+ "Mode(%d=%d)", mode, value);
+ break;
+ }
+ case TERMO_TYPE_UNKNOWN_CSI:
+ l = snprintf (buffer + pos, len - pos,
+ "CSI %c", key->code.number & 0xff);
+ break;
+ }
+
+ if (l <= 0)
+ return pos;
+ pos += l;
+
+ if (wrapbracket)
+ {
+ l = snprintf (buffer + pos, len - pos, ">");
+ if (l <= 0)
+ return pos;
+ pos += l;
+ }
+ return pos;
+}
+
+const char *
+termo_strpkey (termo_t *tk,
+ const char *str, termo_key_t *key, termo_format_t format)
+{
+ struct modnames *mods = &modnames[
+ !!(format & TERMO_FORMAT_LONGMOD) +
+ !!(format & TERMO_FORMAT_ALTISMETA) * 2 +
+ !!(format & TERMO_FORMAT_LOWERMOD) * 4];
+
+ key->modifiers = 0;
+
+ if ((format & TERMO_FORMAT_CARETCTRL) && str[0] == '^' && str[1])
+ {
+ str = termo_strpkey (tk,
+ str + 1, key, format & ~TERMO_FORMAT_CARETCTRL);
+
+ if (!str
+ || key->type != TERMO_TYPE_KEY
+ || key->code.codepoint < '@'
+ || key->code.codepoint > '_'
+ || key->modifiers != 0)
+ return NULL;
+
+ if (key->code.codepoint >= 'A'
+ && key->code.codepoint <= 'Z')
+ key->code.codepoint += 0x20;
+ key->modifiers = TERMO_KEYMOD_CTRL;
+ fill_multibyte (tk, key);
+ return (char *) str;
+ }
+
+ const char *sep_at;
+ while ((sep_at = strchr (str,
+ (format & TERMO_FORMAT_SPACEMOD) ? ' ' : '-')))
+ {
+ size_t n = sep_at - str;
+ if (n == strlen (mods->alt) && !strncmp (mods->alt, str, n))
+ key->modifiers |= TERMO_KEYMOD_ALT;
+ else if (n == strlen (mods->ctrl) && !strncmp (mods->ctrl, str, n))
+ key->modifiers |= TERMO_KEYMOD_CTRL;
+ else if (n == strlen (mods->shift) && !strncmp (mods->shift, str, n))
+ key->modifiers |= TERMO_KEYMOD_SHIFT;
+ else
+ break;
+
+ str = sep_at + 1;
+ }
+
+ size_t nbytes;
+ ssize_t snbytes;
+ const char *endstr;
+
+ if ((endstr = termo_lookup_keyname_format
+ (tk, str, &key->code.sym, format)))
+ {
+ key->type = TERMO_TYPE_KEYSYM;
+ str = endstr;
+ }
+ else if (sscanf(str, "F%d%zn", &key->code.number, &snbytes) == 1)
+ {
+ key->type = TERMO_TYPE_FUNCTION;
+ str += snbytes;
+ }
+ // Multibyte must be last
+ else if (parse_multibyte (tk, (unsigned const char *) str, strlen (str),
+ &key->code.codepoint, &nbytes) == TERMO_RES_KEY)
+ {
+ key->type = TERMO_TYPE_KEY;
+ fill_multibyte (tk, key);
+ str += nbytes;
+ }
+ // TODO: Consider mouse events?
+ else
+ return NULL;
+
+ termo_canonicalise (tk, key);
+ return (char *) str;
+}
+
+int
+termo_keycmp (termo_t *tk,
+ const termo_key_t *key1p, const termo_key_t *key2p)
+{
+ /* Copy the key structs since we'll be modifying them */
+ termo_key_t key1 = *key1p, key2 = *key2p;
+
+ termo_canonicalise (tk, &key1);
+ termo_canonicalise (tk, &key2);
+
+ if (key1.type != key2.type)
+ return key1.type - key2.type;
+
+ switch (key1.type)
+ {
+ case TERMO_TYPE_KEY:
+ if (key1.code.codepoint != key2.code.codepoint)
+ return key1.code.codepoint - key2.code.codepoint;
+ break;
+ case TERMO_TYPE_KEYSYM:
+ if (key1.code.sym != key2.code.sym)
+ return key1.code.sym - key2.code.sym;
+ break;
+ case TERMO_TYPE_FUNCTION:
+ case TERMO_TYPE_UNKNOWN_CSI:
+ if (key1.code.number != key2.code.number)
+ return key1.code.number - key2.code.number;
+ break;
+ case TERMO_TYPE_MOUSE:
+ {
+ int cmp = memcmp (&key1.code.mouse, &key2.code.mouse,
+ sizeof key1.code.mouse);
+ if (cmp != 0)
+ return cmp;
+ break;
+ }
+ case TERMO_TYPE_POSITION:
+ {
+ int line1, col1, line2, col2;
+ termo_interpret_position (tk, &key1, &line1, &col1);
+ termo_interpret_position (tk, &key2, &line2, &col2);
+ if (line1 != line2)
+ return line1 - line2;
+ return col1 - col2;
+ }
+ case TERMO_TYPE_MODEREPORT:
+ {
+ int initial1, initial2, mode1, mode2, value1, value2;
+ termo_interpret_modereport (tk, &key1, &initial1, &mode1, &value1);
+ termo_interpret_modereport (tk, &key2, &initial2, &mode2, &value2);
+ if (initial1 != initial2)
+ return initial1 - initial2;
+ if (mode1 != mode2)
+ return mode1 - mode2;
+ return value1 - value2;
+ }
+ }
+ return key1.modifiers - key2.modifiers;
+}
+