1 | /* |
2 | * QEMU readline utility |
3 | * |
4 | * Copyright (c) 2003-2004 Fabrice Bellard |
5 | * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal |
8 | * in the Software without restriction, including without limitation the rights |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
10 | * copies of the Software, and to permit persons to whom the Software is |
11 | * furnished to do so, subject to the following conditions: |
12 | * |
13 | * The above copyright notice and this permission notice shall be included in |
14 | * all copies or substantial portions of the Software. |
15 | * |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
22 | * THE SOFTWARE. |
23 | */ |
24 | |
25 | #include "qemu/osdep.h" |
26 | #include "qemu/readline.h" |
27 | #include "qemu/ctype.h" |
28 | #include "qemu/cutils.h" |
29 | |
30 | #define IS_NORM 0 |
31 | #define IS_ESC 1 |
32 | #define IS_CSI 2 |
33 | #define IS_SS3 3 |
34 | |
35 | void readline_show_prompt(ReadLineState *rs) |
36 | { |
37 | rs->printf_func(rs->opaque, "%s" , rs->prompt); |
38 | rs->flush_func(rs->opaque); |
39 | rs->last_cmd_buf_index = 0; |
40 | rs->last_cmd_buf_size = 0; |
41 | rs->esc_state = IS_NORM; |
42 | } |
43 | |
44 | /* update the displayed command line */ |
45 | static void readline_update(ReadLineState *rs) |
46 | { |
47 | int i, delta, len; |
48 | |
49 | if (rs->cmd_buf_size != rs->last_cmd_buf_size || |
50 | memcmp(rs->cmd_buf, rs->last_cmd_buf, rs->cmd_buf_size) != 0) { |
51 | for (i = 0; i < rs->last_cmd_buf_index; i++) { |
52 | rs->printf_func(rs->opaque, "\033[D" ); |
53 | } |
54 | rs->cmd_buf[rs->cmd_buf_size] = '\0'; |
55 | if (rs->read_password) { |
56 | len = strlen(rs->cmd_buf); |
57 | for (i = 0; i < len; i++) { |
58 | rs->printf_func(rs->opaque, "*" ); |
59 | } |
60 | } else { |
61 | rs->printf_func(rs->opaque, "%s" , rs->cmd_buf); |
62 | } |
63 | rs->printf_func(rs->opaque, "\033[K" ); |
64 | memcpy(rs->last_cmd_buf, rs->cmd_buf, rs->cmd_buf_size); |
65 | rs->last_cmd_buf_size = rs->cmd_buf_size; |
66 | rs->last_cmd_buf_index = rs->cmd_buf_size; |
67 | } |
68 | if (rs->cmd_buf_index != rs->last_cmd_buf_index) { |
69 | delta = rs->cmd_buf_index - rs->last_cmd_buf_index; |
70 | if (delta > 0) { |
71 | for (i = 0; i < delta; i++) { |
72 | rs->printf_func(rs->opaque, "\033[C" ); |
73 | } |
74 | } else { |
75 | delta = -delta; |
76 | for (i = 0; i < delta; i++) { |
77 | rs->printf_func(rs->opaque, "\033[D" ); |
78 | } |
79 | } |
80 | rs->last_cmd_buf_index = rs->cmd_buf_index; |
81 | } |
82 | rs->flush_func(rs->opaque); |
83 | } |
84 | |
85 | static void readline_insert_char(ReadLineState *rs, int ch) |
86 | { |
87 | if (rs->cmd_buf_index < READLINE_CMD_BUF_SIZE) { |
88 | memmove(rs->cmd_buf + rs->cmd_buf_index + 1, |
89 | rs->cmd_buf + rs->cmd_buf_index, |
90 | rs->cmd_buf_size - rs->cmd_buf_index); |
91 | rs->cmd_buf[rs->cmd_buf_index] = ch; |
92 | rs->cmd_buf_size++; |
93 | rs->cmd_buf_index++; |
94 | } |
95 | } |
96 | |
97 | static void readline_backward_char(ReadLineState *rs) |
98 | { |
99 | if (rs->cmd_buf_index > 0) { |
100 | rs->cmd_buf_index--; |
101 | } |
102 | } |
103 | |
104 | static void readline_forward_char(ReadLineState *rs) |
105 | { |
106 | if (rs->cmd_buf_index < rs->cmd_buf_size) { |
107 | rs->cmd_buf_index++; |
108 | } |
109 | } |
110 | |
111 | static void readline_delete_char(ReadLineState *rs) |
112 | { |
113 | if (rs->cmd_buf_index < rs->cmd_buf_size) { |
114 | memmove(rs->cmd_buf + rs->cmd_buf_index, |
115 | rs->cmd_buf + rs->cmd_buf_index + 1, |
116 | rs->cmd_buf_size - rs->cmd_buf_index - 1); |
117 | rs->cmd_buf_size--; |
118 | } |
119 | } |
120 | |
121 | static void readline_backspace(ReadLineState *rs) |
122 | { |
123 | if (rs->cmd_buf_index > 0) { |
124 | readline_backward_char(rs); |
125 | readline_delete_char(rs); |
126 | } |
127 | } |
128 | |
129 | static void readline_backword(ReadLineState *rs) |
130 | { |
131 | int start; |
132 | |
133 | if (rs->cmd_buf_index == 0 || rs->cmd_buf_index > rs->cmd_buf_size) { |
134 | return; |
135 | } |
136 | |
137 | start = rs->cmd_buf_index - 1; |
138 | |
139 | /* find first word (backwards) */ |
140 | while (start > 0) { |
141 | if (!qemu_isspace(rs->cmd_buf[start])) { |
142 | break; |
143 | } |
144 | |
145 | --start; |
146 | } |
147 | |
148 | /* find first space (backwards) */ |
149 | while (start > 0) { |
150 | if (qemu_isspace(rs->cmd_buf[start])) { |
151 | ++start; |
152 | break; |
153 | } |
154 | |
155 | --start; |
156 | } |
157 | |
158 | /* remove word */ |
159 | if (start < rs->cmd_buf_index) { |
160 | memmove(rs->cmd_buf + start, |
161 | rs->cmd_buf + rs->cmd_buf_index, |
162 | rs->cmd_buf_size - rs->cmd_buf_index); |
163 | rs->cmd_buf_size -= rs->cmd_buf_index - start; |
164 | rs->cmd_buf_index = start; |
165 | } |
166 | } |
167 | |
168 | static void readline_bol(ReadLineState *rs) |
169 | { |
170 | rs->cmd_buf_index = 0; |
171 | } |
172 | |
173 | static void readline_eol(ReadLineState *rs) |
174 | { |
175 | rs->cmd_buf_index = rs->cmd_buf_size; |
176 | } |
177 | |
178 | static void readline_up_char(ReadLineState *rs) |
179 | { |
180 | int idx; |
181 | |
182 | if (rs->hist_entry == 0) { |
183 | return; |
184 | } |
185 | if (rs->hist_entry == -1) { |
186 | /* Find latest entry */ |
187 | for (idx = 0; idx < READLINE_MAX_CMDS; idx++) { |
188 | if (rs->history[idx] == NULL) { |
189 | break; |
190 | } |
191 | } |
192 | rs->hist_entry = idx; |
193 | } |
194 | rs->hist_entry--; |
195 | if (rs->hist_entry >= 0) { |
196 | pstrcpy(rs->cmd_buf, sizeof(rs->cmd_buf), |
197 | rs->history[rs->hist_entry]); |
198 | rs->cmd_buf_index = rs->cmd_buf_size = strlen(rs->cmd_buf); |
199 | } |
200 | } |
201 | |
202 | static void readline_down_char(ReadLineState *rs) |
203 | { |
204 | if (rs->hist_entry == -1) { |
205 | return; |
206 | } |
207 | if (rs->hist_entry < READLINE_MAX_CMDS - 1 && |
208 | rs->history[++rs->hist_entry] != NULL) { |
209 | pstrcpy(rs->cmd_buf, sizeof(rs->cmd_buf), |
210 | rs->history[rs->hist_entry]); |
211 | } else { |
212 | rs->cmd_buf[0] = 0; |
213 | rs->hist_entry = -1; |
214 | } |
215 | rs->cmd_buf_index = rs->cmd_buf_size = strlen(rs->cmd_buf); |
216 | } |
217 | |
218 | static void readline_hist_add(ReadLineState *rs, const char *cmdline) |
219 | { |
220 | char *hist_entry, *new_entry; |
221 | int idx; |
222 | |
223 | if (cmdline[0] == '\0') { |
224 | return; |
225 | } |
226 | new_entry = NULL; |
227 | if (rs->hist_entry != -1) { |
228 | /* We were editing an existing history entry: replace it */ |
229 | hist_entry = rs->history[rs->hist_entry]; |
230 | idx = rs->hist_entry; |
231 | if (strcmp(hist_entry, cmdline) == 0) { |
232 | goto same_entry; |
233 | } |
234 | } |
235 | /* Search cmdline in history buffers */ |
236 | for (idx = 0; idx < READLINE_MAX_CMDS; idx++) { |
237 | hist_entry = rs->history[idx]; |
238 | if (hist_entry == NULL) { |
239 | break; |
240 | } |
241 | if (strcmp(hist_entry, cmdline) == 0) { |
242 | same_entry: |
243 | new_entry = hist_entry; |
244 | /* Put this entry at the end of history */ |
245 | memmove(&rs->history[idx], &rs->history[idx + 1], |
246 | (READLINE_MAX_CMDS - (idx + 1)) * sizeof(char *)); |
247 | rs->history[READLINE_MAX_CMDS - 1] = NULL; |
248 | for (; idx < READLINE_MAX_CMDS; idx++) { |
249 | if (rs->history[idx] == NULL) { |
250 | break; |
251 | } |
252 | } |
253 | break; |
254 | } |
255 | } |
256 | if (idx == READLINE_MAX_CMDS) { |
257 | /* Need to get one free slot */ |
258 | g_free(rs->history[0]); |
259 | memmove(rs->history, &rs->history[1], |
260 | (READLINE_MAX_CMDS - 1) * sizeof(char *)); |
261 | rs->history[READLINE_MAX_CMDS - 1] = NULL; |
262 | idx = READLINE_MAX_CMDS - 1; |
263 | } |
264 | if (new_entry == NULL) { |
265 | new_entry = g_strdup(cmdline); |
266 | } |
267 | rs->history[idx] = new_entry; |
268 | rs->hist_entry = -1; |
269 | } |
270 | |
271 | /* completion support */ |
272 | |
273 | void readline_add_completion(ReadLineState *rs, const char *str) |
274 | { |
275 | if (rs->nb_completions < READLINE_MAX_COMPLETIONS) { |
276 | int i; |
277 | for (i = 0; i < rs->nb_completions; i++) { |
278 | if (!strcmp(rs->completions[i], str)) { |
279 | return; |
280 | } |
281 | } |
282 | rs->completions[rs->nb_completions++] = g_strdup(str); |
283 | } |
284 | } |
285 | |
286 | void readline_set_completion_index(ReadLineState *rs, int index) |
287 | { |
288 | rs->completion_index = index; |
289 | } |
290 | |
291 | static int completion_comp(const void *a, const void *b) |
292 | { |
293 | return strcmp(*(const char **) a, *(const char **) b); |
294 | } |
295 | |
296 | static void readline_completion(ReadLineState *rs) |
297 | { |
298 | int len, i, j, max_width, nb_cols, max_prefix; |
299 | char *cmdline; |
300 | |
301 | rs->nb_completions = 0; |
302 | |
303 | cmdline = g_strndup(rs->cmd_buf, rs->cmd_buf_index); |
304 | rs->completion_finder(rs->opaque, cmdline); |
305 | g_free(cmdline); |
306 | |
307 | /* no completion found */ |
308 | if (rs->nb_completions <= 0) { |
309 | return; |
310 | } |
311 | if (rs->nb_completions == 1) { |
312 | len = strlen(rs->completions[0]); |
313 | for (i = rs->completion_index; i < len; i++) { |
314 | readline_insert_char(rs, rs->completions[0][i]); |
315 | } |
316 | /* extra space for next argument. XXX: make it more generic */ |
317 | if (len > 0 && rs->completions[0][len - 1] != '/') { |
318 | readline_insert_char(rs, ' '); |
319 | } |
320 | } else { |
321 | qsort(rs->completions, rs->nb_completions, sizeof(char *), |
322 | completion_comp); |
323 | rs->printf_func(rs->opaque, "\n" ); |
324 | max_width = 0; |
325 | max_prefix = 0; |
326 | for (i = 0; i < rs->nb_completions; i++) { |
327 | len = strlen(rs->completions[i]); |
328 | if (i == 0) { |
329 | max_prefix = len; |
330 | } else { |
331 | if (len < max_prefix) { |
332 | max_prefix = len; |
333 | } |
334 | for (j = 0; j < max_prefix; j++) { |
335 | if (rs->completions[i][j] != rs->completions[0][j]) { |
336 | max_prefix = j; |
337 | } |
338 | } |
339 | } |
340 | if (len > max_width) { |
341 | max_width = len; |
342 | } |
343 | } |
344 | if (max_prefix > 0) |
345 | for (i = rs->completion_index; i < max_prefix; i++) { |
346 | readline_insert_char(rs, rs->completions[0][i]); |
347 | } |
348 | max_width += 2; |
349 | if (max_width < 10) { |
350 | max_width = 10; |
351 | } else if (max_width > 80) { |
352 | max_width = 80; |
353 | } |
354 | nb_cols = 80 / max_width; |
355 | j = 0; |
356 | for (i = 0; i < rs->nb_completions; i++) { |
357 | rs->printf_func(rs->opaque, "%-*s" , max_width, rs->completions[i]); |
358 | if (++j == nb_cols || i == (rs->nb_completions - 1)) { |
359 | rs->printf_func(rs->opaque, "\n" ); |
360 | j = 0; |
361 | } |
362 | } |
363 | readline_show_prompt(rs); |
364 | } |
365 | for (i = 0; i < rs->nb_completions; i++) { |
366 | g_free(rs->completions[i]); |
367 | } |
368 | } |
369 | |
370 | static void readline_clear_screen(ReadLineState *rs) |
371 | { |
372 | rs->printf_func(rs->opaque, "\033[2J\033[1;1H" ); |
373 | readline_show_prompt(rs); |
374 | } |
375 | |
376 | /* return true if command handled */ |
377 | void readline_handle_byte(ReadLineState *rs, int ch) |
378 | { |
379 | switch (rs->esc_state) { |
380 | case IS_NORM: |
381 | switch (ch) { |
382 | case 1: |
383 | readline_bol(rs); |
384 | break; |
385 | case 4: |
386 | readline_delete_char(rs); |
387 | break; |
388 | case 5: |
389 | readline_eol(rs); |
390 | break; |
391 | case 9: |
392 | readline_completion(rs); |
393 | break; |
394 | case 12: |
395 | readline_clear_screen(rs); |
396 | break; |
397 | case 10: |
398 | case 13: |
399 | rs->cmd_buf[rs->cmd_buf_size] = '\0'; |
400 | if (!rs->read_password) { |
401 | readline_hist_add(rs, rs->cmd_buf); |
402 | } |
403 | rs->printf_func(rs->opaque, "\n" ); |
404 | rs->cmd_buf_index = 0; |
405 | rs->cmd_buf_size = 0; |
406 | rs->last_cmd_buf_index = 0; |
407 | rs->last_cmd_buf_size = 0; |
408 | rs->readline_func(rs->opaque, rs->cmd_buf, rs->readline_opaque); |
409 | break; |
410 | case 23: |
411 | /* ^W */ |
412 | readline_backword(rs); |
413 | break; |
414 | case 27: |
415 | rs->esc_state = IS_ESC; |
416 | break; |
417 | case 127: |
418 | case 8: |
419 | readline_backspace(rs); |
420 | break; |
421 | case 155: |
422 | rs->esc_state = IS_CSI; |
423 | break; |
424 | default: |
425 | if (ch >= 32) { |
426 | readline_insert_char(rs, ch); |
427 | } |
428 | break; |
429 | } |
430 | break; |
431 | case IS_ESC: |
432 | if (ch == '[') { |
433 | rs->esc_state = IS_CSI; |
434 | rs->esc_param = 0; |
435 | } else if (ch == 'O') { |
436 | rs->esc_state = IS_SS3; |
437 | rs->esc_param = 0; |
438 | } else { |
439 | rs->esc_state = IS_NORM; |
440 | } |
441 | break; |
442 | case IS_CSI: |
443 | switch (ch) { |
444 | case 'A': |
445 | case 'F': |
446 | readline_up_char(rs); |
447 | break; |
448 | case 'B': |
449 | case 'E': |
450 | readline_down_char(rs); |
451 | break; |
452 | case 'D': |
453 | readline_backward_char(rs); |
454 | break; |
455 | case 'C': |
456 | readline_forward_char(rs); |
457 | break; |
458 | case '0' ... '9': |
459 | rs->esc_param = rs->esc_param * 10 + (ch - '0'); |
460 | goto the_end; |
461 | case '~': |
462 | switch (rs->esc_param) { |
463 | case 1: |
464 | readline_bol(rs); |
465 | break; |
466 | case 3: |
467 | readline_delete_char(rs); |
468 | break; |
469 | case 4: |
470 | readline_eol(rs); |
471 | break; |
472 | } |
473 | break; |
474 | default: |
475 | break; |
476 | } |
477 | rs->esc_state = IS_NORM; |
478 | the_end: |
479 | break; |
480 | case IS_SS3: |
481 | switch (ch) { |
482 | case 'F': |
483 | readline_eol(rs); |
484 | break; |
485 | case 'H': |
486 | readline_bol(rs); |
487 | break; |
488 | } |
489 | rs->esc_state = IS_NORM; |
490 | break; |
491 | } |
492 | readline_update(rs); |
493 | } |
494 | |
495 | void readline_start(ReadLineState *rs, const char *prompt, int read_password, |
496 | ReadLineFunc *readline_func, void *opaque) |
497 | { |
498 | pstrcpy(rs->prompt, sizeof(rs->prompt), prompt); |
499 | rs->readline_func = readline_func; |
500 | rs->readline_opaque = opaque; |
501 | rs->read_password = read_password; |
502 | readline_restart(rs); |
503 | } |
504 | |
505 | void readline_restart(ReadLineState *rs) |
506 | { |
507 | rs->cmd_buf_index = 0; |
508 | rs->cmd_buf_size = 0; |
509 | } |
510 | |
511 | const char *readline_get_history(ReadLineState *rs, unsigned int index) |
512 | { |
513 | if (index >= READLINE_MAX_CMDS) { |
514 | return NULL; |
515 | } |
516 | return rs->history[index]; |
517 | } |
518 | |
519 | void readline_free(ReadLineState *rs) |
520 | { |
521 | int i; |
522 | |
523 | if (!rs) { |
524 | return; |
525 | } |
526 | for (i = 0; i < READLINE_MAX_CMDS; i++) { |
527 | g_free(rs->history[i]); |
528 | } |
529 | g_free(rs); |
530 | } |
531 | |
532 | ReadLineState *readline_init(ReadLinePrintfFunc *printf_func, |
533 | ReadLineFlushFunc *flush_func, |
534 | void *opaque, |
535 | ReadLineCompletionFunc *completion_finder) |
536 | { |
537 | ReadLineState *rs = g_new0(ReadLineState, 1); |
538 | |
539 | rs->hist_entry = -1; |
540 | rs->opaque = opaque; |
541 | rs->printf_func = printf_func; |
542 | rs->flush_func = flush_func; |
543 | rs->completion_finder = completion_finder; |
544 | |
545 | return rs; |
546 | } |
547 | |