[BACK]Return to xterm-keys.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/xterm-keys.c, Revision 1.9

1.9     ! nicm        1: /* $OpenBSD: xterm-keys.c,v 1.8 2011/01/01 03:43:20 nicm Exp $ */
1.1       nicm        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
1.5       nicm       30:  * 3 Alt
                     31:  * 4 Shift + Alt
                     32:  * 5 Ctrl
                     33:  * 6 Shift + Ctrl
                     34:  * 7 Alt + Ctrl
1.1       nicm       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:
1.8       nicm       51: const struct xterm_keys_entry xterm_keys_table[] = {
1.1       nicm       52:        { KEYC_F1,      "\033[1;_P" },
1.3       nicm       53:        { KEYC_F1,      "\033O_P" },
1.1       nicm       54:        { KEYC_F2,      "\033[1;_Q" },
1.3       nicm       55:        { KEYC_F2,      "\033O_Q" },
1.1       nicm       56:        { KEYC_F3,      "\033[1;_R" },
1.3       nicm       57:        { KEYC_F3,      "\033O_R" },
1.1       nicm       58:        { KEYC_F4,      "\033[1;_S" },
1.3       nicm       59:        { KEYC_F4,      "\033O_S" },
1.1       nicm       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:
1.5       nicm       88: /*
1.4       nicm       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:  */
1.1       nicm       92: int
                     93: xterm_keys_match(const char *template, const char *buf, size_t len)
                     94: {
                     95:        size_t  pos;
                     96:
1.4       nicm       97:        if (len == 0)
1.1       nicm       98:                return (0);
                     99:
                    100:        pos = 0;
                    101:        do {
                    102:                if (*template != '_' && buf[pos] != *template)
1.4       nicm      103:                        return (-1);
1.1       nicm      104:        } while (pos++ != len && *++template != '\0');
                    105:
1.4       nicm      106:        if (*template != '\0')  /* partial */
                    107:                return (1);
                    108:
                    109:        return (0);
1.1       nicm      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;
1.6       nicm      117:        int     param, modifiers;
1.1       nicm      118:
                    119:        idx = strcspn(template, "_");
                    120:        if (idx >= len)
                    121:                return (0);
1.6       nicm      122:        param = buf[idx] - '1';
                    123:
                    124:        modifiers = 0;
                    125:        if (param & 1)
                    126:                modifiers |= KEYC_SHIFT;
                    127:        if (param & 2)
                    128:                modifiers |= KEYC_ESCAPE;
                    129:        if (param & 4)
                    130:                modifiers |= KEYC_CTRL;
1.7       nicm      131:        if (param & 8)
                    132:                modifiers |= KEYC_ESCAPE;
1.6       nicm      133:        return (modifiers);
1.1       nicm      134: }
                    135:
1.4       nicm      136: /*
                    137:  * Lookup key from a buffer against the table. Returns 0 for found (and the
                    138:  * key), -1 for not found, 1 for partial match.
                    139:  */
1.1       nicm      140: int
1.4       nicm      141: xterm_keys_find(const char *buf, size_t len, size_t *size, int *key)
1.1       nicm      142: {
1.8       nicm      143:        const struct xterm_keys_entry   *entry;
                    144:        u_int                            i;
1.1       nicm      145:
                    146:        for (i = 0; i < nitems(xterm_keys_table); i++) {
                    147:                entry = &xterm_keys_table[i];
1.4       nicm      148:                switch (xterm_keys_match(entry->template, buf, len)) {
                    149:                case 0:
                    150:                        *size = strlen(entry->template);
                    151:                        *key = entry->key;
                    152:                        *key |= xterm_keys_modifiers(entry->template, buf, len);
                    153:                        return (0);
                    154:                case 1:
                    155:                        return (1);
                    156:                }
1.1       nicm      157:        }
1.4       nicm      158:        return (-1);
1.1       nicm      159: }
                    160:
                    161: /* Lookup a key number from the table. */
                    162: char *
                    163: xterm_keys_lookup(int key)
                    164: {
1.8       nicm      165:        const struct xterm_keys_entry   *entry;
                    166:        u_int                            i;
                    167:        int                              modifiers;
                    168:        char                            *out;
1.1       nicm      169:
1.6       nicm      170:        modifiers = 1;
                    171:        if (key & KEYC_SHIFT)
                    172:                modifiers += 1;
                    173:        if (key & KEYC_ESCAPE)
                    174:                modifiers += 2;
                    175:        if (key & KEYC_CTRL)
                    176:                modifiers += 4;
1.1       nicm      177:
                    178:        /*
                    179:         * If the key has no modifiers, return NULL and let it fall through to
                    180:         * the normal lookup.
                    181:         */
1.6       nicm      182:        if (modifiers == 1)
1.1       nicm      183:                return (NULL);
                    184:
                    185:        /* Otherwise, find the key in the table. */
                    186:        key &= ~(KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL);
                    187:        for (i = 0; i < nitems(xterm_keys_table); i++) {
                    188:                entry = &xterm_keys_table[i];
                    189:                if (key == entry->key)
                    190:                        break;
                    191:        }
                    192:        if (i == nitems(xterm_keys_table))
                    193:                return (NULL);
1.5       nicm      194:
1.1       nicm      195:        /* Copy the template and replace the modifier. */
                    196:        out = xstrdup(entry->template);
                    197:        out[strcspn(out, "_")] = '0' + modifiers;
                    198:        return (out);
                    199: }