Head

GCC Code Coverage Report

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


/* $OpenBSD: xterm-keys.c,v 1.22 2017/05/07 21:25:59 nicm Exp $ */

/*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <string.h>

#include "tmux.h"

/*
 * xterm-style function keys append one of the following values before the last
 * character:
 *
 * 2 Shift
 * 3 Alt
 * 4 Shift + Alt
 * 5 Ctrl
 * 6 Shift + Ctrl
 * 7 Alt + Ctrl
 * 8 Shift + Alt + Ctrl
 *
 * Rather than parsing them, just match against a table.
 *
 * There are three forms for F1-F4 (\\033O_P and \\033O1;_P and \\033[1;_P).
 * We accept any but always output the latter (it comes first in the table).
 */

static int	xterm_keys_match(const char *, const char *, size_t, size_t *,
		    key_code *);
static int	xterm_keys_modifiers(const char *, size_t, size_t *,
		    key_code *);

struct xterm_keys_entry {
	key_code	 key;
	const char	*template;
};

static const struct xterm_keys_entry xterm_keys_table[] = {
	{ KEYC_F1,	"\033[1;_P" },
	{ KEYC_F1,	"\033O1;_P" },
	{ KEYC_F1,	"\033O_P" },
	{ KEYC_F2,	"\033[1;_Q" },
	{ KEYC_F2,	"\033O1;_Q" },
	{ KEYC_F2,	"\033O_Q" },
	{ KEYC_F3,	"\033[1;_R" },
	{ KEYC_F3,	"\033O1;_R" },
	{ KEYC_F3,	"\033O_R" },
	{ KEYC_F4,	"\033[1;_S" },
	{ KEYC_F4,	"\033O1;_S" },
	{ KEYC_F4,	"\033O_S" },
	{ KEYC_F5,	"\033[15;_~" },
	{ KEYC_F6,	"\033[17;_~" },
	{ KEYC_F7,	"\033[18;_~" },
	{ KEYC_F8,	"\033[19;_~" },
	{ KEYC_F9,	"\033[20;_~" },
	{ KEYC_F10,	"\033[21;_~" },
	{ KEYC_F11,	"\033[23;_~" },
	{ KEYC_F12,	"\033[24;_~" },
	{ KEYC_UP,	"\033[1;_A" },
	{ KEYC_DOWN,	"\033[1;_B" },
	{ KEYC_RIGHT,	"\033[1;_C" },
	{ KEYC_LEFT,	"\033[1;_D" },
	{ KEYC_HOME,	"\033[1;_H" },
	{ KEYC_END,	"\033[1;_F" },
	{ KEYC_PPAGE,	"\033[5;_~" },
	{ KEYC_NPAGE,	"\033[6;_~" },
	{ KEYC_IC,	"\033[2;_~" },
	{ KEYC_DC,	"\033[3;_~" },

	{ '!',          "\033[27;_;33~" },
	{ '#',		"\033[27;_;35~" },
	{ '(',		"\033[27;_;40~" },
	{ ')',		"\033[27;_;41~" },
	{ '+',		"\033[27;_;43~" },
	{ ',',		"\033[27;_;44~" },
	{ '-',		"\033[27;_;45~" },
	{ '.',		"\033[27;_;46~" },
	{ '0',		"\033[27;_;48~" },
	{ '1',		"\033[27;_;49~" },
	{ '2',		"\033[27;_;50~" },
	{ '3',		"\033[27;_;51~" },
	{ '4',		"\033[27;_;52~" },
	{ '5',		"\033[27;_;53~" },
	{ '6',		"\033[27;_;54~" },
	{ '7',		"\033[27;_;55~" },
	{ '8',		"\033[27;_;56~" },
	{ '9',		"\033[27;_;57~" },
	{ ':',		"\033[27;_;58~" },
	{ ';',		"\033[27;_;59~" },
	{ '<',		"\033[27;_;60~" },
	{ '=',		"\033[27;_;61~" },
	{ '>',		"\033[27;_;62~" },
	{ '?',		"\033[27;_;63~" },
	{ '\'',		"\033[27;_;39~" },
	{ '\r',		"\033[27;_;13~" },
	{ '\t',		"\033[27;_;9~" },
};

/*
 * Match key against buffer, treating _ as a wildcard. Return -1 for no match,
 * 0 for match, 1 if the end of the buffer is reached (need more data).
 */
static int
xterm_keys_match(const char *template, const char *buf, size_t len,
    size_t *size, key_code *modifiers)
{
	size_t	pos;
	int	retval;

	*modifiers = 0;

	if (len == 0)
		return (0);

	pos = 0;
	do {
		if (*template == '_') {
			retval = xterm_keys_modifiers(buf, len, &pos,
			    modifiers);
			if (retval != 0)
				return (retval);
			continue;
		}
		if (buf[pos] != *template)
			return (-1);
		pos++;
	} while (*++template != '\0' && pos != len);

	if (*template != '\0')	/* partial */
		return (1);

	*size = pos;
	return (0);
}

/* Find modifiers from buffer. */
static int
xterm_keys_modifiers(const char *buf, size_t len, size_t *pos,
    key_code *modifiers)
{
	u_int	flags;

	if (len - *pos < 2)
		return (1);

	if (buf[*pos] < '0' || buf[*pos] > '9')
		return (-1);
	flags = buf[(*pos)++] - '0';
	if (buf[*pos] >= '0' && buf[*pos] <= '9')
		flags = (flags * 10) + (buf[(*pos)++] - '0');
	flags -= 1;

	*modifiers = 0;
	if (flags & 1)
		*modifiers |= KEYC_SHIFT;
	if (flags & 2)
		*modifiers |= KEYC_ESCAPE;
	if (flags & 4)
		*modifiers |= KEYC_CTRL;
	if (flags & 8)
		*modifiers |= KEYC_ESCAPE;
	return (0);
}

/*
 * Lookup key from a buffer against the table. Returns 0 for found (and the
 * key), -1 for not found, 1 for partial match.
 */
int
xterm_keys_find(const char *buf, size_t len, size_t *size, key_code *key)
{
	const struct xterm_keys_entry	*entry;
	u_int				 i;
	int				 matched;
	key_code			 modifiers;

	for (i = 0; i < nitems(xterm_keys_table); i++) {
		entry = &xterm_keys_table[i];

		matched = xterm_keys_match(entry->template, buf, len, size,
		    &modifiers);
		if (matched == -1)
			continue;
		if (matched == 0)
			*key = (entry->key|modifiers|KEYC_XTERM);
		return (matched);
	}
	return (-1);
}

/* Lookup a key number from the table. */
char *
xterm_keys_lookup(key_code key)
{
	const struct xterm_keys_entry	*entry;
	u_int				 i;
	key_code			 modifiers;
	char				*out;

	modifiers = 1;
	if (key & KEYC_SHIFT)
		modifiers += 1;
	if (key & KEYC_ESCAPE)
		modifiers += 2;
	if (key & KEYC_CTRL)
		modifiers += 4;

	/*
	 * If the key has no modifiers, return NULL and let it fall through to
	 * the normal lookup.
	 */
	if (modifiers == 1)
		return (NULL);

	/*
	 * If this has the escape modifier, but was not originally an xterm
	 * key, it may be a genuine escape + key. So don't pass it through as
	 * an xterm key or programs like vi may be confused.
	 */
	if ((key & (KEYC_ESCAPE|KEYC_XTERM)) == KEYC_ESCAPE)
		return (NULL);

	/* Otherwise, find the key in the table. */
	key &= KEYC_MASK_KEY;
	for (i = 0; i < nitems(xterm_keys_table); i++) {
		entry = &xterm_keys_table[i];
		if (key == entry->key)
			break;
	}
	if (i == nitems(xterm_keys_table))
		return (NULL);

	/* Copy the template and replace the modifier. */
	out = xstrdup(entry->template);
	out[strcspn(out, "_")] = '0' + modifiers;
	return (out);
}


Generated by: GCOVR (Version 3.3)

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			}