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