avr/cli_readline.c

   1 /*
   2  * (C) Copyright 2014-2016 Leo C. <erbl259-lmu@yahoo.de>
   3  *
   4  * (C) Copyright 2000
   5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   6  *
   7  * Add to readline cmdline-editing by
   8  * (C) Copyright 2005
   9  * JinHua Luo, GuangDong Linux Center, <luo.jinhua@gd-linux.com>
  10  *
  11  * SPDX-License-Identifier:     GPL-2.0
  12  */
  13
  14 #include "cli_readline.h"
  15 #include "common.h"
  16 #include <string.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdbool.h>
  20 #include <ctype.h>
  21
  22 #include "config.h"
  23 #include "con-utils.h"
  24 #include "print-utils.h"
  25 #include "command.h"
  26
  27
  28
  29 char console_buffer[CONFIG_SYS_CBSIZE + 1];     /* console I/O buffer   */
  30
  31 #define CTL_CH(c)                       ((c) - 'a' + 1)
  32 #define CTL_BACKSPACE           ('\b')
  33 #define DEL                                     ((char)255)
  34 #define DEL7                            ((char)127)
  35
  36
  37 /************************************************************************************************/
  38 /* TODO:
  39  *
  40  */
  41
  42 #define ESC                                             0x1b
  43
  44 #define KEY_TAB                 '\t'                                                // TAB key
  45 #define KEY_CR                  '\r'                                                // RETURN key
  46 #define KEY_BACKSPACE           '\b'                                                // Backspace key
  47 #define KEY_ESCAPE              0x1B                                                // ESCAPE (pressed twice)
  48
  49 #define KEY_DOWN                0x80                                                // Down arrow key
  50 #define KEY_UP                  0x81                                                // Up arrow key
  51 #define KEY_LEFT                0x82                                                // Left arrow key
  52 #define KEY_RIGHT               0x83                                                // Right arrow key
  53 #define KEY_HOME                0x84                                                // Home key
  54 #define KEY_DC                  0x85                                                // Delete character key
  55 #define KEY_IC                  0x86                                                // Ins char/toggle ins mode key
  56 #define KEY_NPAGE               0x87                                                // Next-page key
  57 #define KEY_PPAGE               0x88                                                // Previous-page key
  58 #define KEY_END                 0x89                                                // End key
  59 #define KEY_BTAB                0x8A                                                // Back tab key
  60 #define KEY_F1                  0x8B                                                // Function key F1
  61 #define KEY_F(n)                (KEY_F1+(n)-1)                                      // Space for additional 12 function keys
  62
  63
  64 struct fkey_tbl_s {
  65         const FLASH char *sequence;             /* ESC Sequence */
  66         int     code;                                           /* Keycode      */
  67 };
  68
  69 //typedef const FLASH struct fkey_tbl_s fkey_tbl_t;
  70
  71 #define FKEY_TBL_ITEM(_seq, _code)              { FSTR(#_seq), _code }
  72
  73
  74
  75 static const FLASH struct fkey_tbl_s fkey_table[] = {
  76
  77 FKEY_TBL_ITEM(B,   KEY_DOWN),                   // Down arrow key
  78 FKEY_TBL_ITEM(A,   KEY_UP),                             // Up arrow key
  79 FKEY_TBL_ITEM(D,   KEY_LEFT),                   // Left arrow key
  80 FKEY_TBL_ITEM(C,   KEY_RIGHT),                  // Right arrow key
  81 FKEY_TBL_ITEM(1~,  KEY_HOME),                   // Home key
  82 FKEY_TBL_ITEM(3~,  KEY_DC),                             // Delete character key
  83 FKEY_TBL_ITEM(2~,  KEY_IC),                             // Ins char/toggle ins mode key
  84 FKEY_TBL_ITEM(6~,  KEY_NPAGE),                  // Next-page key
  85 FKEY_TBL_ITEM(5~,  KEY_PPAGE),                  // Previous-page key
  86 FKEY_TBL_ITEM(4~,  KEY_END),                    // End key
  87 FKEY_TBL_ITEM(Z,   KEY_BTAB),                   // Back tab key
  88 /* VT400: */
  89 FKEY_TBL_ITEM(11~, KEY_F(1)),                   // Function key F1
  90 FKEY_TBL_ITEM(12~, KEY_F(2)),                   // Function key F2
  91 FKEY_TBL_ITEM(13~, KEY_F(3)),                   // Function key F3
  92 FKEY_TBL_ITEM(14~, KEY_F(4)),                   // Function key F4
  93 FKEY_TBL_ITEM(15~, KEY_F(5)),                   // Function key F5
  94 /* Linux consoe */
  95 FKEY_TBL_ITEM([A,  KEY_F(1)),                   // Function key F1
  96 FKEY_TBL_ITEM([B,  KEY_F(2)),                   // Function key F2
  97 FKEY_TBL_ITEM([C,  KEY_F(3)),                   // Function key F3
  98 FKEY_TBL_ITEM([D,  KEY_F(4)),                   // Function key F4
  99 FKEY_TBL_ITEM([E,  KEY_F(5)),                   // Function key F5
 100
 101 FKEY_TBL_ITEM(17~, KEY_F(6)),                   // Function key F6
 102 FKEY_TBL_ITEM(18~, KEY_F(7)),                   // Function key F7
 103 FKEY_TBL_ITEM(19~, KEY_F(8)),                   // Function key F8
 104 FKEY_TBL_ITEM(20~, KEY_F(9)),                   // Function key F9
 105 FKEY_TBL_ITEM(21~, KEY_F(10)),                  // Function key F10
 106 FKEY_TBL_ITEM(23~, KEY_F(11)),                  // Function key F11
 107 FKEY_TBL_ITEM(24~, KEY_F(12)),                  // Function key F12
 108 { NULL }        /* Mark end of table */
 109 };
 110
 111
 112
 113 typedef enum {
 114         STATE_GROUND,
 115         STATE_ESCAPE,
 116         STATE_CSI_ENTRY,
 117         STATE_SS3
 118 } vtparse_state_t;
 119
 120 #define CHB_SIZE        15
 121
 122 static
 123 int vt_parse (void)
 124 {
 125         static vtparse_state_t state = STATE_GROUND;
 126         char    buf[CHB_SIZE+1];
 127         uint8_t param[2];
 128         uint8_t i_buf;
 129         uint8_t i_param;
 130         int  ch;
 131
 132
 133         while (1) {
 134                 ch = my_getchar(1);
 135 //              debug_getch(state, ch);
 136
 137                 switch (state) {
 138                 case STATE_GROUND:
 139                         if (ch == ESC) {
 140                                 state = STATE_ESCAPE;
 141                                 continue;
 142                         }
 143                         if (ch == 0x7F)                         // BACKSPACE on VT200 sends DEL char
 144                                 ch = KEY_BACKSPACE;             // map it to '\b'
 145                         break;
 146                 case STATE_ESCAPE:
 147                         if (ch < 0)
 148                                 continue;
 149
 150                         if (ch == '[') {
 151                                 state = STATE_CSI_ENTRY;
 152                                 param[0] = param[1] = 0;
 153                                 i_buf = 0;
 154                                 i_param = 0;
 155                                 continue;
 156                         }
 157                         if (ch == 'O') {
 158                                 state = STATE_SS3;
 159                                 continue;
 160                         }
 161                         state = STATE_GROUND;
 162                         break;
 163                 case STATE_SS3:
 164                         if (ch == 'F')                          /* weird */
 165                                 ch = KEY_END;
 166                         state = STATE_GROUND;
 167                         break;
 168                 case STATE_CSI_ENTRY:
 169                         if (ch < 0)
 170                                 continue;
 171
 172                         buf[i_buf] = ch;
 173                         if (i_buf < CHB_SIZE)
 174                                 i_buf++;
 175                         if (ch == ';') {
 176                                 i_param++;
 177                                 continue;
 178                         }
 179                         if (isdigit(ch)) {
 180                                 if (i_param < 2)
 181                                         param[i_param] = param[i_param] * 10 + ch - '0';
 182                                 continue;
 183                         }
 184                         if (ch >= '@' && ch <= '~' && ch != '[') {
 185                                 buf[i_buf] = '\0';
 186                                 int_fast8_t i = 0;
 187                                 while (fkey_table[i].sequence) {
 188                                         if (! strcmp_P (buf, fkey_table[i].sequence)) {
 189                                                 ch = fkey_table[i].code;
 190                                                 break;
 191                                         }
 192                                         i++;
 193                                 }
 194                                 if (fkey_table[i].sequence == NULL) {
 195                                         ch = '$'; /* KEY_ESCAPE; */
 196                                 }
 197                         }
 198                         state = STATE_GROUND;
 199                         break;
 200                 }
 201                 break; /* while */
 202         }
 203
 204         return ch;
 205 }
 206
 207 /************************************************************************************************/
 208
 209 /*
 210  * cmdline-editing related codes from vivi.
 211  * Author: Janghoon Lyu <nandy@mizi.com>
 212  */
 213
 214
 215 struct hist_node_s {
 216         struct hist_node_s *next;
 217         char line[];
 218 };
 219 typedef struct hist_node_s hist_node;
 220
 221
 222 static hist_node *hist_head;
 223 static hist_node *hist_cur;
 224
 225 static void hist_reset(void)
 226 {
 227         hist_cur = hist_head;
 228 }
 229
 230 static hist_node *hist_search_node(char *line)
 231 {
 232         hist_node *p = hist_head;
 233
 234         while (p && strcmp(p->line, line))
 235                 p = p->next;
 236         return p;
 237 }
 238
 239 #if 0
 240 static hist_node *hist_insert(char *line)
 241 {
 242         hist_node *p = (hist_node *) malloc(sizeof (hist_node) + strlen(line) + 1);
 243
 244         if (p) {
 245                 strcpy(p->line, line);
 246                 p->next = hist_head;
 247                 hist_head = p;
 248         }
 249         return p;
 250 }
 251 #endif
 252
 253 static hist_node *hist_new(char *line)
 254 {
 255         hist_node *p = (hist_node *) malloc(sizeof (hist_node) + strlen(line) + 1);
 256
 257         if (p) {
 258                 strcpy(p->line, line);
 259                 p->next = NULL;
 260         }
 261         return p;
 262 }
 263
 264 static hist_node *hist_delete(void)
 265 {
 266         hist_node *p = NULL;
 267         hist_node *q = hist_head;
 268
 269         if (q) {
 270                 while(q->next) {
 271                         p = q;
 272                         q = q->next;
 273                 }
 274                 free(q);
 275                 if (p)
 276                         p->next = NULL;
 277         }
 278         return p;
 279 }
 280
 281 static hist_node *hist_unlink(hist_node *pos)
 282 {
 283         hist_node *p = NULL;
 284         hist_node *q = hist_head;
 285
 286         while(q && q != pos) {
 287                 p = q;
 288                 q = q->next;
 289         }
 290         if (q) {
 291                 if (p)
 292                         p->next = q->next;
 293                 else
 294                         hist_head = q->next;
 295                 q->next = NULL;
 296         }
 297         return q;
 298 }
 299
 300 static uint_fast8_t hist_count(void)
 301 {
 302         hist_node *p = hist_head;
 303         uint_fast8_t n = 0;
 304
 305         while (p) {
 306                 ++n;
 307                 p = p->next;
 308         }
 309         return n;
 310 }
 311
 312 static hist_node *cread_add_to_hist(char *line)
 313 {
 314         hist_node * p;
 315
 316         p = hist_search_node(line);
 317         if (p)
 318                 hist_unlink(p);
 319         else
 320                 p = hist_new(line);
 321
 322         if (p) {
 323                 p->next = hist_head;
 324                 hist_head = p;
 325         }
 326
 327         if (hist_count() > CONFIG_SYS_HIST_MAX)
 328                 hist_delete();
 329         return p;
 330 }
 331
 332 static char *hist_prev(void)
 333 {
 334         hist_node *p = hist_cur;
 335
 336         if (p == NULL)
 337                 return NULL;
 338         hist_cur = p->next;
 339
 340         return  p->line;
 341 }
 342
 343 static char *hist_next(void)
 344 {
 345         hist_node *p = NULL;
 346         hist_node *q = hist_head;
 347
 348         if(q == hist_cur)
 349                 return NULL;
 350
 351         while(q->next != hist_cur) {
 352                 p = q;
 353                 q = q->next;
 354         }
 355         hist_cur = q;
 356
 357         return p ? p->line : "";
 358 }
 359
 360 static char *hist_search_backward(char* buf, uint8_t num)
 361 {
 362         hist_node *p = hist_cur;
 363
 364         if (p == NULL)
 365                 return NULL;
 366
 367         while (p->next && strncmp(p->line, buf, num))
 368                 p = p->next;
 369
 370         if(!strncmp(p->line, buf, num)) {
 371                 hist_cur = p->next;
 372                 return  p->line;
 373         }
 374         return NULL;
 375 }
 376
 377 static char *hist_search_forward (char* buf, uint8_t num)
 378 {
 379         hist_node *p = NULL;
 380         hist_node *match = NULL;
 381         hist_node *q = hist_head;
 382
 383         if(q == hist_cur)
 384                 return NULL;
 385
 386         while(q->next != hist_cur) {
 387                 p = q;
 388                 q = q->next;
 389                 if (p && !strncmp(p->line, buf, num))
 390                         match = p;
 391         }
 392
 393         if(match) {
 394                 hist_cur = match->next;
 395                 return  match->line;
 396         }
 397         return NULL;
 398 }
 399
 400 static void putnstr(char *str, int n)
 401 {
 402         /* printf_P(PSTR("%.*s"), (int)n, str) */
 403         while (n-- && *str)
 404                 putchar(*str++);
 405 }
 406
 407 static void getcmd_putch(int ch) { putchar(ch);}
 408 static int  getcmd_getch(void) { return vt_parse();}
 409 static void getcmd_cbeep(void) { getcmd_putch('\a');}
 410
 411 static void beginning_of_line(uint8_t *num)
 412 {
 413         while (*num) {
 414                 getcmd_putch(CTL_BACKSPACE);
 415                 (*num)--;
 416         }
 417 }
 418
 419 static void erase_to_eol(uint_fast8_t *num, uint_fast8_t *eol_num)
 420 {
 421         if (*num < *eol_num) {
 422                 /* printf_P(PSTR("%*S"), (int)(*eol_num - *num), PSTR("")); */
 423                 print_blanks(*eol_num - *num);
 424                 do {
 425                         getcmd_putch(CTL_BACKSPACE);
 426                 } while (--(*eol_num) > *num);
 427         }
 428 }
 429
 430 static void refresh_to_eol(char *buf, uint_fast8_t *num, uint_fast8_t *eol_num)
 431 {
 432         if (*num < *eol_num) {
 433                 uint_fast8_t wlen = *eol_num - *num;
 434                 putnstr(buf + *num, wlen);
 435                 *num = *eol_num;
 436         }
 437 }
 438
 439 static void cread_add_char(char ichar, bool insert, uint_fast8_t *num,
 440                uint_fast8_t *eol_num, char *buf, uint_fast8_t len)
 441 {
 442         uint_fast8_t wlen;
 443
 444         /* room ??? */
 445         if (insert || *num == *eol_num) {
 446                 if (*eol_num > len - 1) {
 447                         getcmd_cbeep();
 448                         return;
 449                 }
 450                 (*eol_num)++;
 451         }
 452
 453         if (insert) {
 454                 wlen = *eol_num - *num;
 455                 if (wlen > 1)
 456                         memmove(&buf[*num+1], &buf[*num], wlen-1);
 457
 458                 buf[*num] = ichar;
 459                 putnstr(buf + *num, wlen);
 460                 (*num)++;
 461                 while (--wlen)
 462                         getcmd_putch(CTL_BACKSPACE);
 463         } else {
 464                 /* echo the character */
 465                 buf[*num] = ichar;
 466                 putnstr(buf + *num, 1);
 467                 (*num)++;
 468         }
 469 }
 470
 471 static void cread_add_str(char *str, bool insert, uint_fast8_t *num,
 472                                 uint_fast8_t *eol_num, char *buf, uint_fast8_t len)
 473 {
 474         char c;
 475
 476         while ((c = *str++) != '\0')
 477                 cread_add_char(c, insert, num, eol_num, buf, len);
 478 }
 479
 480 static int cread_line(const FLASH char *const prompt, char *buf,
 481                         uint_fast8_t len, bool enable_history)
 482 {
 483         uint_fast8_t num = 0;
 484         uint_fast8_t eol_num = 0;
 485         bool insert = 1;
 486
 487         (void) prompt;
 488
 489         if (buf[0])
 490                 cread_add_str(buf, 1, &num, &eol_num, buf, len);
 491
 492         hist_reset();
 493
 494         while (1) {
 495                 int ichar = getcmd_getch();
 496
 497                 if ((ichar == '\n') || (ichar == '\r')) {
 498                         putchar('\n');
 499                         break;
 500                 }
 501
 502
 503                 switch (ichar) {
 504
 505                 case KEY_HOME:
 506                 case CTL_CH('a'):
 507                         beginning_of_line(&num);
 508                         break;
 509                 case CTL_CH('c'):                       /* ^C - break */
 510                         putchar('\n');
 511                         *buf = '\0';                    /* discard input */
 512                         return -1;
 513                 case KEY_RIGHT:
 514                 case CTL_CH('f'):                       /* forward-char */
 515                         if (num < eol_num) {
 516                                 getcmd_putch(buf[num]);
 517                                 num++;
 518                         }
 519                         break;
 520                 case KEY_LEFT:
 521                 case CTL_CH('b'):                       /* backward-char */
 522                         if (num) {
 523                                 getcmd_putch(CTL_BACKSPACE);
 524                                 num--;
 525                         }
 526                         break;
 527                 case KEY_DC:
 528                 case CTL_CH('d'):                       /* delete-char */
 529                         if (num < eol_num) {
 530                                 uint_fast8_t wlen = eol_num - num - 1;
 531                                 if (wlen) {
 532                                         memmove(&buf[num], &buf[num+1], wlen);
 533                                         putnstr(buf + num, wlen);
 534                                 }
 535
 536                                 getcmd_putch(' ');
 537                                 do {
 538                                         getcmd_putch(CTL_BACKSPACE);
 539                                 } while (wlen--);
 540                                 eol_num--;
 541                         }
 542                         break;
 543                 case CTL_CH('k'):                       /* kill-line */
 544                         erase_to_eol(&num, &eol_num);
 545                         break;
 546                 case KEY_END:
 547                 case CTL_CH('e'):
 548                         refresh_to_eol(buf, &num, &eol_num);
 549                         break;
 550                 case KEY_IC:
 551                 case CTL_CH('o'):
 552                         insert = !insert;
 553                         break;
 554                 case CTL_CH('x'):
 555                 case CTL_CH('u'):                       /* kill-whole-line */
 556                         beginning_of_line(&num);
 557                         erase_to_eol(&num, &eol_num);
 558                         break;
 559                 case DEL:
 560                 case DEL7:
 561                 case 8:                                         /* backward-delete-char */
 562                         if (num) {
 563                                 uint_fast8_t wlen = eol_num - --num;
 564                                 buf[eol_num] = ' ';
 565                                 memmove(&buf[num], &buf[num+1], wlen);
 566                                 getcmd_putch(CTL_BACKSPACE);
 567                                 putnstr(buf + num, wlen);
 568                                 do {
 569                                         getcmd_putch(CTL_BACKSPACE);
 570                                 } while (--wlen);
 571                                 eol_num--;
 572                         }
 573                         break;
 574                 case KEY_UP:
 575                 case CTL_CH('p'):                       /* previous-history */
 576                 case KEY_DOWN:
 577                 case CTL_CH('n'):                       /* next-history */
 578                         if (enable_history) {
 579                                 char *hline;
 580
 581                                 if (ichar == CTL_CH('p') || ichar == KEY_UP)
 582                                         hline = hist_prev();
 583                                 else
 584                                         hline = hist_next();
 585
 586                                 if (hline) {
 587                                         /* first, go home */
 588                                         beginning_of_line(&num);
 589                                         /* overwrite current line */
 590                                         cread_add_str(hline, 0, &num, &eol_num, buf, len);
 591                                         /* erase to end of line */
 592                                         erase_to_eol(&num, &eol_num);
 593
 594                                 } else {
 595                                         getcmd_cbeep();
 596                                 }
 597                         } else {
 598                                 getcmd_cbeep();
 599                         }
 600                         break;
 601                 case KEY_PPAGE:                 /* history-search-backward */
 602                 case KEY_NPAGE:                 /* history-search-forward */
 603                         if (enable_history) {
 604                                 char *hline;
 605                                 if (ichar == KEY_PPAGE)
 606                                         hline = hist_search_backward(buf, num);
 607                                 else
 608                                         hline = hist_search_forward(buf, num);
 609
 610                                 if (hline) {
 611                                         uint_fast8_t num2 = num;
 612                                         /* overwrite current line from cursor position */
 613                                         cread_add_str(hline+num, 0, &num2, &eol_num, buf, len);
 614                                         /* erase to end of line */
 615                                         erase_to_eol(&num2, &eol_num);
 616                                         /* cursor back */
 617                                         while (num2-- > num)
 618                                                 getcmd_putch(CTL_BACKSPACE);
 619                                 } else {
 620                                         getcmd_cbeep();
 621                                 }
 622                         } else {
 623                                 getcmd_cbeep();
 624                         }
 625                         break;
 626 #ifdef CONFIG_AUTO_COMPLETE
 627                 case '\t': {
 628                         int num2, col;
 629
 630                         /* do not autocomplete when in the middle */
 631                         if (num < eol_num) {
 632                                 getcmd_cbeep();
 633                                 break;
 634                         }
 635
 636                         buf[num] = '\0';
 637                         col = strlen_P(prompt) + eol_num;
 638                         num2 = num;
 639                         if (cmd_auto_complete(prompt, buf, &num2, &col)) {
 640                                 col = num2 - num;
 641                                 num += col;
 642                                 eol_num += col;
 643                         }
 644                         break;
 645                 }
 646 #endif
 647                 default:
 648                         if (isprint(ichar))
 649                                 cread_add_char(ichar, insert, &num, &eol_num, buf, len);
 650                         break;
 651                 }
 652         }
 653         while (eol_num && buf[eol_num-1] == ' ')
 654                 --eol_num;                      /* remove trailing blanks */
 655         buf[eol_num] = '\0';    /* lose the newline */
 656
 657         if (enable_history && buf[0])
 658                 cread_add_to_hist(buf);
 659         return eol_num;
 660 }
 661
 662 /****************************************************************************/
 663
 664 int cli_readline(const FLASH char *const prompt, bool enable_history)
 665 {
 666         /*
 667          * If console_buffer isn't 0-length the user will be prompted to modify
 668          * it instead of entering it from scratch as desired.
 669          */
 670         console_buffer[0] = '\0';
 671
 672         if (prompt)
 673                 my_puts_P(prompt);
 674
 675         return cread_line(prompt, console_buffer, CONFIG_SYS_CBSIZE, enable_history);
 676 }