1 /* vi: set sw=4 ts=4: */
5 * Copyright (C) 2008 Rob Landley <rob@landley.net>
6 * Copyright (C) 2008 Denys Vlasenko <vda.linux@googlemail.com>
8 * Licensed under GPLv2, see file LICENSE in this source tree.
12 int64_t FAST_FUNC
read_key(int fd
, char *buffer
, int timeout
)
18 /* Known escape sequences for cursor and function keys */
19 static const char esccmds
[] ALIGN1
= {
20 'O','A' |0x80,KEYCODE_UP
,
21 'O','B' |0x80,KEYCODE_DOWN
,
22 'O','C' |0x80,KEYCODE_RIGHT
,
23 'O','D' |0x80,KEYCODE_LEFT
,
24 'O','H' |0x80,KEYCODE_HOME
,
25 'O','F' |0x80,KEYCODE_END
,
27 'O','P' |0x80,KEYCODE_FUN1
,
28 /* [ESC] ESC O [2] P - [Alt-][Shift-]F1 */
29 /* ESC [ O 1 ; 2 P - Shift-F1 */
30 /* ESC [ O 1 ; 3 P - Alt-F1 */
31 /* ESC [ O 1 ; 4 P - Alt-Shift-F1 */
32 /* ESC [ O 1 ; 5 P - Ctrl-F1 */
33 /* ESC [ O 1 ; 6 P - Ctrl-Shift-F1 */
34 'O','Q' |0x80,KEYCODE_FUN2
,
35 'O','R' |0x80,KEYCODE_FUN3
,
36 'O','S' |0x80,KEYCODE_FUN4
,
38 '[','A' |0x80,KEYCODE_UP
,
39 '[','B' |0x80,KEYCODE_DOWN
,
40 '[','C' |0x80,KEYCODE_RIGHT
,
41 '[','D' |0x80,KEYCODE_LEFT
,
42 /* ESC [ 1 ; 2 x, where x = A/B/C/D: Shift-<arrow> */
43 /* ESC [ 1 ; 3 x, where x = A/B/C/D: Alt-<arrow> - implemented below */
44 /* ESC [ 1 ; 4 x, where x = A/B/C/D: Alt-Shift-<arrow> */
45 /* ESC [ 1 ; 5 x, where x = A/B/C/D: Ctrl-<arrow> - implemented below */
46 /* ESC [ 1 ; 6 x, where x = A/B/C/D: Ctrl-Shift-<arrow> */
47 '[','H' |0x80,KEYCODE_HOME
, /* xterm */
48 '[','F' |0x80,KEYCODE_END
, /* xterm */
49 /* [ESC] ESC [ [2] H - [Alt-][Shift-]Home (End similarly?) */
50 /* '[','Z' |0x80,KEYCODE_SHIFT_TAB, */
51 '[','1','~' |0x80,KEYCODE_HOME
, /* vt100? linux vt? or what? */
52 '[','2','~' |0x80,KEYCODE_INSERT
,
53 /* ESC [ 2 ; 3 ~ - Alt-Insert */
54 '[','3','~' |0x80,KEYCODE_DELETE
,
55 /* [ESC] ESC [ 3 [;2] ~ - [Alt-][Shift-]Delete */
56 /* ESC [ 3 ; 3 ~ - Alt-Delete */
57 /* ESC [ 3 ; 5 ~ - Ctrl-Delete */
58 '[','4','~' |0x80,KEYCODE_END
, /* vt100? linux vt? or what? */
59 '[','5','~' |0x80,KEYCODE_PAGEUP
,
60 /* ESC [ 5 ; 3 ~ - Alt-PgUp */
61 /* ESC [ 5 ; 5 ~ - Ctrl-PgUp */
62 /* ESC [ 5 ; 7 ~ - Ctrl-Alt-PgUp */
63 '[','6','~' |0x80,KEYCODE_PAGEDOWN
,
64 '[','7','~' |0x80,KEYCODE_HOME
, /* vt100? linux vt? or what? */
65 '[','8','~' |0x80,KEYCODE_END
, /* vt100? linux vt? or what? */
67 '[','1','1','~'|0x80,KEYCODE_FUN1
,
68 '[','1','2','~'|0x80,KEYCODE_FUN2
,
69 '[','1','3','~'|0x80,KEYCODE_FUN3
,
70 '[','1','4','~'|0x80,KEYCODE_FUN4
,
71 '[','1','5','~'|0x80,KEYCODE_FUN5
,
72 /* [ESC] ESC [ 1 5 [;2] ~ - [Alt-][Shift-]F5 */
73 '[','1','7','~'|0x80,KEYCODE_FUN6
,
74 '[','1','8','~'|0x80,KEYCODE_FUN7
,
75 '[','1','9','~'|0x80,KEYCODE_FUN8
,
76 '[','2','0','~'|0x80,KEYCODE_FUN9
,
77 '[','2','1','~'|0x80,KEYCODE_FUN10
,
78 '[','2','3','~'|0x80,KEYCODE_FUN11
,
79 '[','2','4','~'|0x80,KEYCODE_FUN12
,
80 /* ESC [ 2 4 ; 2 ~ - Shift-F12 */
81 /* ESC [ 2 4 ; 3 ~ - Alt-F12 */
82 /* ESC [ 2 4 ; 4 ~ - Alt-Shift-F12 */
83 /* ESC [ 2 4 ; 5 ~ - Ctrl-F12 */
84 /* ESC [ 2 4 ; 6 ~ - Ctrl-Shift-F12 */
86 /* '[','1',';','5','A' |0x80,KEYCODE_CTRL_UP , - unused */
87 /* '[','1',';','5','B' |0x80,KEYCODE_CTRL_DOWN , - unused */
88 '[','1',';','5','C' |0x80,KEYCODE_CTRL_RIGHT
,
89 '[','1',';','5','D' |0x80,KEYCODE_CTRL_LEFT
,
90 /* '[','1',';','3','A' |0x80,KEYCODE_ALT_UP , - unused */
91 /* '[','1',';','3','B' |0x80,KEYCODE_ALT_DOWN , - unused */
92 '[','1',';','3','C' |0x80,KEYCODE_ALT_RIGHT
,
93 '[','1',';','3','D' |0x80,KEYCODE_ALT_LEFT
,
94 /* '[','3',';','3','~' |0x80,KEYCODE_ALT_DELETE, - unused */
101 buffer
++; /* saved chars counter is in buffer[-1] now */
105 n
= (unsigned char)buffer
[-1];
107 /* If no data, wait for input.
108 * If requested, wait TIMEOUT ms. TIMEOUT = -1 is useful
109 * if fd can be in non-blocking mode.
112 if (safe_poll(&pfd
, 1, timeout
) == 0) {
118 /* It is tempting to read more than one byte here,
119 * but it breaks pasting. Example: at shell prompt,
120 * user presses "c","a","t" and then pastes "\nline\n".
121 * When we were reading 3 bytes here, we were eating
122 * "li" too, and cat was getting wrong input.
124 n
= safe_read(fd
, buffer
, 1);
130 unsigned char c
= buffer
[0];
133 memmove(buffer
, buffer
+ 1, n
);
134 /* Only ESC starts ESC sequences */
141 /* Loop through known ESC sequences */
143 while (*seq
!= '\0') {
144 /* n - position in sequence we did not read yet */
145 int i
= 0; /* position in sequence to compare */
147 /* Loop through chars in this sequence */
149 /* So far escape sequence matched up to [i-1] */
151 /* Need more chars, read another one if it wouldn't block.
152 * Note that escape sequences come in as a unit,
153 * so if we block for long it's not really an escape sequence.
154 * Timeout is needed to reconnect escape sequences
155 * split up by transmission over a serial console. */
156 if (safe_poll(&pfd
, 1, 50) == 0) {
158 * Array is sorted from shortest to longest,
159 * we can't match anything later in array -
160 * anything later is longer than this seq.
161 * Break out of both loops. */
165 if (safe_read(fd
, buffer
+ n
, 1) <= 0) {
166 /* If EAGAIN, then fd is O_NONBLOCK and poll lied:
167 * in fact, there is no data. */
168 if (errno
!= EAGAIN
) {
169 /* otherwise: it's EOF/error */
177 if (buffer
[i
] != (seq
[i
] & 0x7f)) {
178 /* This seq doesn't match, go to next */
180 /* Forward to last char */
181 while (!(*seq
& 0x80))
183 /* Skip it and the keycode which follows */
188 /* Entire seq matched */
190 /* n -= i; memmove(...);
191 * would be more correct,
192 * but we never read ahead that much,
193 * and n == i here. */
195 return (signed char)seq
[i
+1];
200 /* We did not find matching sequence.
201 * We possibly read and stored more input in buffer[] by now.
202 * n = bytes read. Try to read more until we time out.
204 while (n
< KEYCODE_BUFFER_SIZE
-1) { /* 1 for count byte at buffer[-1] */
205 if (safe_poll(&pfd
, 1, 50) == 0) {
210 if (safe_read(fd
, buffer
+ n
, 1) <= 0) {
211 /* If EAGAIN, then fd is O_NONBLOCK and poll lied:
212 * in fact, there is no data. */
213 if (errno
!= EAGAIN
) {
214 /* otherwise: it's EOF/error */
221 /* Try to decipher "ESC [ NNN ; NNN R" sequence */
222 if ((ENABLE_FEATURE_EDITING_ASK_TERMINAL
223 || ENABLE_FEATURE_VI_ASK_TERMINAL
224 || ENABLE_FEATURE_LESS_ASK_TERMINAL
228 && buffer
[n
-1] == 'R'
229 && isdigit(buffer
[1])
232 unsigned long row
, col
;
234 row
= strtoul(buffer
+ 1, &end
, 10);
235 if (*end
!= ';' || !isdigit(end
[1]))
237 col
= strtoul(end
+ 1, &end
, 10);
240 if (row
< 1 || col
< 1 || (row
| col
) > 0x7fff)
244 /* Pack into "1 <row15bits> <col16bits>" 32-bit sequence */
245 col
|= (((-1 << 15) | row
) << 16);
246 /* Return it in high-order word */
247 return ((int64_t) col
<< 32) | (uint32_t)KEYCODE_CURSOR_POS
;
253 /* Alt-x is usually returned as ESC x.
254 * Report ESC, x is remembered for the next call.
260 /* We were doing "buffer[-1] = n; return c;" here, but this results
261 * in unknown key sequences being interpreted as ESC + garbage.
262 * This was not useful. Pretend there was no key pressed,
263 * go and wait for a new keypress:
269 void FAST_FUNC
read_key_ungets(char *buffer
, const char *str
, unsigned len
)
271 unsigned cur_len
= (unsigned char)buffer
[0];
272 if (len
> KEYCODE_BUFFER_SIZE
-1 - cur_len
)
273 len
= KEYCODE_BUFFER_SIZE
-1 - cur_len
;
274 memcpy(buffer
+ 1 + cur_len
, str
, len
);