[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.14

1.14    ! nicm        1: /* $OpenBSD: xterm-keys.c,v 1.13 2014/02/10 11:20:41 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:  *
1.10      nicm       39:  * There are three forms for F1-F4 (\\033O_P and \\033O1;_P and \\033[1;_P).
                     40:  * We accept any but always output the latter (it comes first in the table).
1.1       nicm       41:  */
                     42:
1.14    ! nicm       43: int    xterm_keys_match(const char *, const char *, size_t, size_t *, u_int *);
        !            44: int    xterm_keys_modifiers(const char *, size_t, size_t *, u_int *);
1.1       nicm       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.10      nicm       53:        { KEYC_F1,      "\033O1;_P" },
1.3       nicm       54:        { KEYC_F1,      "\033O_P" },
1.1       nicm       55:        { KEYC_F2,      "\033[1;_Q" },
1.10      nicm       56:        { KEYC_F2,      "\033O1;_Q" },
1.3       nicm       57:        { KEYC_F2,      "\033O_Q" },
1.1       nicm       58:        { KEYC_F3,      "\033[1;_R" },
1.10      nicm       59:        { KEYC_F3,      "\033O1;_R" },
1.3       nicm       60:        { KEYC_F3,      "\033O_R" },
1.1       nicm       61:        { KEYC_F4,      "\033[1;_S" },
1.10      nicm       62:        { KEYC_F4,      "\033O1;_S" },
1.3       nicm       63:        { KEYC_F4,      "\033O_S" },
1.1       nicm       64:        { KEYC_F5,      "\033[15;_~" },
                     65:        { KEYC_F6,      "\033[17;_~" },
                     66:        { KEYC_F7,      "\033[18;_~" },
                     67:        { KEYC_F8,      "\033[19;_~" },
                     68:        { KEYC_F9,      "\033[20;_~" },
                     69:        { KEYC_F10,     "\033[21;_~" },
                     70:        { KEYC_F11,     "\033[23;_~" },
                     71:        { KEYC_F12,     "\033[24;_~" },
                     72:        { KEYC_F13,     "\033[25;_~" },
                     73:        { KEYC_F14,     "\033[26;_~" },
                     74:        { KEYC_F15,     "\033[28;_~" },
                     75:        { KEYC_F16,     "\033[29;_~" },
                     76:        { KEYC_F17,     "\033[31;_~" },
                     77:        { KEYC_F18,     "\033[32;_~" },
                     78:        { KEYC_F19,     "\033[33;_~" },
                     79:        { KEYC_F20,     "\033[34;_~" },
                     80:        { KEYC_UP,      "\033[1;_A" },
                     81:        { KEYC_DOWN,    "\033[1;_B" },
                     82:        { KEYC_RIGHT,   "\033[1;_C" },
                     83:        { KEYC_LEFT,    "\033[1;_D" },
                     84:        { KEYC_HOME,    "\033[1;_H" },
                     85:        { KEYC_END,     "\033[1;_F" },
                     86:        { KEYC_PPAGE,   "\033[5;_~" },
                     87:        { KEYC_NPAGE,   "\033[6;_~" },
                     88:        { KEYC_IC,      "\033[2;_~" },
                     89:        { KEYC_DC,      "\033[3;_~" },
1.11      nicm       90:
                     91:        { '!',          "\033[27;_;33~" },
                     92:        { '#',          "\033[27;_;35~" },
                     93:        { '(',          "\033[27;_;40~" },
                     94:        { ')',          "\033[27;_;41~" },
                     95:        { '+',          "\033[27;_;43~" },
                     96:        { ',',          "\033[27;_;44~" },
                     97:        { '-',          "\033[27;_;45~" },
                     98:        { '.',          "\033[27;_;46~" },
                     99:        { '0',          "\033[27;_;48~" },
                    100:        { '1',          "\033[27;_;49~" },
                    101:        { '2',          "\033[27;_;50~" },
                    102:        { '3',          "\033[27;_;51~" },
                    103:        { '4',          "\033[27;_;52~" },
                    104:        { '5',          "\033[27;_;53~" },
                    105:        { '6',          "\033[27;_;54~" },
                    106:        { '7',          "\033[27;_;55~" },
                    107:        { '8',          "\033[27;_;56~" },
                    108:        { '9',          "\033[27;_;57~" },
                    109:        { ':',          "\033[27;_;58~" },
                    110:        { ';',          "\033[27;_;59~" },
                    111:        { '<',          "\033[27;_;60~" },
                    112:        { '=',          "\033[27;_;61~" },
                    113:        { '>',          "\033[27;_;62~" },
                    114:        { '?',          "\033[27;_;63~" },
                    115:        { '\'',         "\033[27;_;39~" },
                    116:        { '\r',         "\033[27;_;13~" },
                    117:        { '\t',         "\033[27;_;9~" },
1.1       nicm      118: };
                    119:
1.5       nicm      120: /*
1.4       nicm      121:  * Match key against buffer, treating _ as a wildcard. Return -1 for no match,
                    122:  * 0 for match, 1 if the end of the buffer is reached (need more data).
                    123:  */
1.1       nicm      124: int
1.14    ! nicm      125: xterm_keys_match(const char *template, const char *buf, size_t len,
        !           126:     size_t *size, u_int *modifiers)
1.1       nicm      127: {
                    128:        size_t  pos;
1.14    ! nicm      129:        int     retval;
1.1       nicm      130:
1.4       nicm      131:        if (len == 0)
1.1       nicm      132:                return (0);
                    133:
                    134:        pos = 0;
                    135:        do {
1.14    ! nicm      136:                if (*template == '_') {
        !           137:                        retval = xterm_keys_modifiers(buf, len, &pos,
        !           138:                            modifiers);
        !           139:                        if (retval != 0)
        !           140:                                return (retval);
1.13      nicm      141:                        continue;
1.14    ! nicm      142:                }
1.13      nicm      143:                if (buf[pos] != *template)
1.4       nicm      144:                        return (-1);
1.14    ! nicm      145:                pos++;
        !           146:        } while (*++template != '\0' && pos != len);
1.1       nicm      147:
1.4       nicm      148:        if (*template != '\0')  /* partial */
                    149:                return (1);
                    150:
1.14    ! nicm      151:        *size = pos;
1.4       nicm      152:        return (0);
1.1       nicm      153: }
                    154:
1.14    ! nicm      155: /* Find modifiers from buffer. */
1.1       nicm      156: int
1.14    ! nicm      157: xterm_keys_modifiers(const char *buf, size_t len, size_t *pos, u_int *modifiers)
1.1       nicm      158: {
1.14    ! nicm      159:        u_int   flags;
1.1       nicm      160:
1.14    ! nicm      161:        if (len - *pos < 2)
        !           162:                return (1);
1.6       nicm      163:
1.14    ! nicm      164:        if (buf[*pos] < '0' || buf[*pos] > '9')
        !           165:                return (-1);
        !           166:        flags = buf[(*pos)++] - '0';
        !           167:        if (buf[*pos] >= '0' && buf[*pos] <= '9')
        !           168:                flags = (flags * 10) + (buf[(*pos)++] - '0');
        !           169:        flags -= 1;
        !           170:
        !           171:        *modifiers = 0;
        !           172:        if (flags & 1)
        !           173:                *modifiers |= KEYC_SHIFT;
        !           174:        if (flags & 2)
        !           175:                *modifiers |= KEYC_ESCAPE;
        !           176:        if (flags & 4)
        !           177:                *modifiers |= KEYC_CTRL;
        !           178:        if (flags & 8)
        !           179:                *modifiers |= KEYC_ESCAPE;
        !           180:        return (0);
1.1       nicm      181: }
                    182:
1.4       nicm      183: /*
                    184:  * Lookup key from a buffer against the table. Returns 0 for found (and the
                    185:  * key), -1 for not found, 1 for partial match.
                    186:  */
1.1       nicm      187: int
1.4       nicm      188: xterm_keys_find(const char *buf, size_t len, size_t *size, int *key)
1.1       nicm      189: {
1.8       nicm      190:        const struct xterm_keys_entry   *entry;
1.14    ! nicm      191:        u_int                            i, modifiers;
        !           192:        int                              matched;
1.1       nicm      193:
                    194:        for (i = 0; i < nitems(xterm_keys_table); i++) {
                    195:                entry = &xterm_keys_table[i];
1.14    ! nicm      196:
        !           197:                matched = xterm_keys_match(entry->template, buf, len, size,
        !           198:                    &modifiers);
        !           199:                if (matched == -1)
        !           200:                        continue;
        !           201:                if (matched == 0)
        !           202:                        *key = entry->key | modifiers;
        !           203:                return (matched);
1.1       nicm      204:        }
1.4       nicm      205:        return (-1);
1.1       nicm      206: }
                    207:
                    208: /* Lookup a key number from the table. */
                    209: char *
                    210: xterm_keys_lookup(int key)
                    211: {
1.8       nicm      212:        const struct xterm_keys_entry   *entry;
                    213:        u_int                            i;
                    214:        int                              modifiers;
                    215:        char                            *out;
1.1       nicm      216:
1.6       nicm      217:        modifiers = 1;
                    218:        if (key & KEYC_SHIFT)
                    219:                modifiers += 1;
                    220:        if (key & KEYC_ESCAPE)
                    221:                modifiers += 2;
                    222:        if (key & KEYC_CTRL)
                    223:                modifiers += 4;
1.1       nicm      224:
                    225:        /*
                    226:         * If the key has no modifiers, return NULL and let it fall through to
                    227:         * the normal lookup.
                    228:         */
1.6       nicm      229:        if (modifiers == 1)
1.1       nicm      230:                return (NULL);
                    231:
                    232:        /* Otherwise, find the key in the table. */
                    233:        key &= ~(KEYC_SHIFT|KEYC_ESCAPE|KEYC_CTRL);
                    234:        for (i = 0; i < nitems(xterm_keys_table); i++) {
                    235:                entry = &xterm_keys_table[i];
                    236:                if (key == entry->key)
                    237:                        break;
                    238:        }
                    239:        if (i == nitems(xterm_keys_table))
                    240:                return (NULL);
1.5       nicm      241:
1.1       nicm      242:        /* Copy the template and replace the modifier. */
                    243:        out = xstrdup(entry->template);
                    244:        out[strcspn(out, "_")] = '0' + modifiers;
                    245:        return (out);
                    246: }