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 } 516