xterm-keys.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20
  21 #include <string.h>
  22
  23 #include "tmux.h"
  24
  25 /*
  26  * xterm-style function keys append one of the following values before the last
  27  * character:
  28  *
  29  * 2 Shift
  30  * 3 Alt
  31  * 4 Shift + Alt
  32  * 5 Ctrl
  33  * 6 Shift + Ctrl
  34  * 7 Alt + Ctrl
  35  * 8 Shift + Alt + Ctrl
  36  *
  37  * Rather than parsing them, just match against a table.
  38  *
  39  * There are two forms for F1-F4 (\\033O_P or \\033[1;_P). We accept either but
  40  * always output the latter (it comes first in the table).
  41  */
  42
  43 int     xterm_keys_match(const char *, const char *, size_t);
  44 int     xterm_keys_modifiers(const char *, const char *, size_t);
  45
  46 struct xterm_keys_entry {
  47         int              key;
  48         const char      *template;
  49 };
  50
  51 struct xterm_keys_entry xterm_keys_table[] = {
  52         { KEYC_F1,      "\033[1;_P" },
  53         { KEYC_F1,      "\033O_P" },
  54         { KEYC_F2,      "\033[1;_Q" },
  55         { KEYC_F2,      "\033O_Q" },
  56         { KEYC_F3,      "\033[1;_R" },
  57         { KEYC_F3,      "\033O_R" },
  58         { KEYC_F4,      "\033[1;_S" },
  59         { KEYC_F4,      "\033O_S" },
  60         { KEYC_F5,      "\033[15;_~" },
  61         { KEYC_F6,      "\033[17;_~" },
  62         { KEYC_F7,      "\033[18;_~" },
  63         { KEYC_F8,      "\033[19;_~" },
  64         { KEYC_F9,      "\033[20;_~" },
  65         { KEYC_F10,     "\033[21;_~" },
  66         { KEYC_F11,     "\033[23;_~" },
  67         { KEYC_F12,     "\033[24;_~" },
  68         { KEYC_F13,     "\033[25;_~" },
  69         { KEYC_F14,     "\033[26;_~" },
  70         { KEYC_F15,     "\033[28;_~" },
  71         { KEYC_F16,     "\033[29;_~" },
  72         { KEYC_F17,     "\033[31;_~" },
  73         { KEYC_F18,     "\033[32;_~" },
  74         { KEYC_F19,     "\033[33;_~" },
  75         { KEYC_F20,     "\033[34;_~" },
  76         { KEYC_UP,      "\033[1;_A" },
  77         { KEYC_DOWN,    "\033[1;_B" },
  78         { KEYC_RIGHT,   "\033[1;_C" },
  79         { KEYC_LEFT,    "\033[1;_D" },
  80         { KEYC_HOME,    "\033[1;_H" },
  81         { KEYC_END,     "\033[1;_F" },
  82         { KEYC_PPAGE,   "\033[5;_~" },
  83         { KEYC_NPAGE,   "\033[6;_~" },
  84         { KEYC_IC,      "\033[2;_~" },
  85         { KEYC_DC,      "\033[3;_~" },
  86 };
  87
  88 /*
  89  * Match key against buffer, treating _ as a wildcard. Return -1 for no match,
  90  * 0 for match, 1 if the end of the buffer is reached (need more data).
  91  */
  92 int
  93 xterm_keys_match(const char *template, const char *buf, size_t len)
  94 {
  95         size_t  pos;
  96
  97         if (len == 0)
  98                 return (0);
  99
 100         pos = 0;
 101         do {
 102                 if (*template != '_' && buf[pos] != *template)
 103                         return (-1);
 104         } while (pos++ != len && *++template != '\0');
 105
 106         if (*template != '\0')  /* partial */
 107                 return (1);
 108
 109         return (0);
 110 }
 111
 112 /* Find modifiers based on template. */
 113 int
 114 xterm_keys_modifiers(const char *template, const char *buf, size_t len)
 115 {
 116         size_t  idx;
 117
 118         idx = strcspn(template, "_");
 119         if (idx >= len)
 120                 return (0);
 121         switch (buf[idx]) {
 122         case '2':
 123                 return (KEYC_SHIFT);
 124         case '3':
 125                 return (KEYC_ESCAPE);
 126         case '4':
 127                 return (KEYC_SHIFT|KEYC_ESCAPE);
 128         case '5':
 129                 return (KEYC_CTRL);
 130         case '6':
 131                 return (KEYC_SHIFT|KEYC_CTRL);
 132         case '7':
 133                 return (KEYC_ESCAPE|KEYC_CTRL);
 134         case '8':
 135                 return (KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL);
 136         }
 137         return (0);
 138 }
 139
 140 /*
 141  * Lookup key from a buffer against the table. Returns 0 for found (and the
 142  * key), -1 for not found, 1 for partial match.
 143  */
 144 int
 145 xterm_keys_find(const char *buf, size_t len, size_t *size, int *key)
 146 {
 147         struct xterm_keys_entry *entry;
 148         u_int                    i;
 149
 150         for (i = 0; i < nitems(xterm_keys_table); i++) {
 151                 entry = &xterm_keys_table[i];
 152                 switch (xterm_keys_match(entry->template, buf, len)) {
 153                 case 0:
 154                         *size = strlen(entry->template);
 155                         *key = entry->key;
 156                         *key |= xterm_keys_modifiers(entry->template, buf, len);
 157                         return (0);
 158                 case 1:
 159                         return (1);
 160                 }
 161         }
 162         return (-1);
 163 }
 164
 165 /* Lookup a key number from the table. */
 166 char *
 167 xterm_keys_lookup(int key)
 168 {
 169         struct xterm_keys_entry *entry;
 170         u_int                    i;
 171         int                      modifiers;
 172         char                    *out;
 173
 174 #define KEY_MODIFIERS(key, modifiers) \
 175         (((key) & (KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL)) == (modifiers))
 176         modifiers = 0;
 177         if (KEY_MODIFIERS(key, KEYC_SHIFT))
 178                 modifiers = 2;
 179         else if (KEY_MODIFIERS(key, KEYC_ESCAPE))
 180                 modifiers = 3;
 181         else if (KEY_MODIFIERS(key, KEYC_SHIFT|KEYC_ESCAPE))
 182                 modifiers = 4;
 183         else if (KEY_MODIFIERS(key, KEYC_CTRL))
 184                 modifiers = 5;
 185         else if (KEY_MODIFIERS(key, KEYC_SHIFT|KEYC_CTRL))
 186                 modifiers = 6;
 187         else if (KEY_MODIFIERS(key, KEYC_ESCAPE|KEYC_CTRL))
 188                 modifiers = 7;
 189         else if (KEY_MODIFIERS(key, KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL))
 190                 modifiers = 8;
 191 #undef KEY_MODIFIERS
 192
 193         /*
 194          * If the key has no modifiers, return NULL and let it fall through to
 195          * the normal lookup.
 196          */
 197         if (modifiers == 0)
 198                 return (NULL);
 199
 200         /* Otherwise, find the key in the table. */
 201         key &= ~(KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL);
 202         for (i = 0; i < nitems(xterm_keys_table); i++) {
 203                 entry = &xterm_keys_table[i];
 204                 if (key == entry->key)
 205                         break;
 206         }
 207         if (i == nitems(xterm_keys_table))
 208                 return (NULL);
 209
 210         /* Copy the template and replace the modifier. */
 211         out = xstrdup(entry->template);
 212         out[strcspn(out, "_")] = '0' + modifiers;
 213         return (out);
 214 }