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