GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/tmux/xterm-keys.c Lines: 0 64 0.0 %
Date: 2017-11-13 Branches: 0 54 0.0 %

Line Branch Exec Source
1
/* $OpenBSD: xterm-keys.c,v 1.22 2017/05/07 21:25:59 nicm Exp $ */
2
3
/*
4
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
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
43
static int	xterm_keys_match(const char *, const char *, size_t, size_t *,
44
		    key_code *);
45
static int	xterm_keys_modifiers(const char *, size_t, size_t *,
46
		    key_code *);
47
48
struct xterm_keys_entry {
49
	key_code	 key;
50
	const char	*template;
51
};
52
53
static 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
 */
118
static int
119
xterm_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. */
152
static int
153
xterm_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
 */
184
int
185
xterm_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. */
207
char *
208
xterm_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
}