]>
Commit | Line | Data |
---|---|---|
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 | } |