1 /* 2 * Copyright (C) 1984-2015 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11 /* 12 * Routines to decode user commands. 13 * 14 * This is all table driven. 15 * A command table is a sequence of command descriptors. 16 * Each command descriptor is a sequence of bytes with the following format: 17 * <c1><c2>...<cN><0><action> 18 * The characters c1,c2,...,cN are the command string; that is, 19 * the characters which the user must type. 20 * It is terminated by a null <0> byte. 21 * The byte after the null byte is the action code associated 22 * with the command string. 23 * If an action byte is OR-ed with A_EXTRA, this indicates 24 * that the option byte is followed by an extra string. 25 * 26 * There may be many command tables. 27 * The first (default) table is built-in. 28 * Other tables are read in from "lesskey" files. 29 * All the tables are linked together and are searched in order. 30 */ 31 32 #include "less.h" 33 #include "cmd.h" 34 #include "lesskey.h" 35 36 extern int erase_char, erase2_char, kill_char; 37 extern int secure; 38 39 #define SK(k) \ 40 SK_SPECIAL_KEY, (k), 6, 1, 1, 1 41 /* 42 * Command table is ordered roughly according to expected 43 * frequency of use, so the common commands are near the beginning. 44 */ 45 46 static unsigned char cmdtable[] = 47 { 48 '\r',0, A_F_LINE, 49 '\n',0, A_F_LINE, 50 'e',0, A_F_LINE, 51 'j',0, A_F_LINE, 52 SK(SK_DOWN_ARROW),0, A_F_LINE, 53 CONTROL('E'),0, A_F_LINE, 54 CONTROL('N'),0, A_F_LINE, 55 'k',0, A_B_LINE, 56 'y',0, A_B_LINE, 57 CONTROL('Y'),0, A_B_LINE, 58 SK(SK_CONTROL_K),0, A_B_LINE, 59 CONTROL('P'),0, A_B_LINE, 60 SK(SK_UP_ARROW),0, A_B_LINE, 61 'J',0, A_FF_LINE, 62 'K',0, A_BF_LINE, 63 'Y',0, A_BF_LINE, 64 'd',0, A_F_SCROLL, 65 CONTROL('D'),0, A_F_SCROLL, 66 'u',0, A_B_SCROLL, 67 CONTROL('U'),0, A_B_SCROLL, 68 ' ',0, A_F_SCREEN, 69 'f',0, A_F_SCREEN, 70 CONTROL('F'),0, A_F_SCREEN, 71 CONTROL('V'),0, A_F_SCREEN, 72 SK(SK_PAGE_DOWN),0, A_F_SCREEN, 73 'b',0, A_B_SCREEN, 74 CONTROL('B'),0, A_B_SCREEN, 75 ESC,'v',0, A_B_SCREEN, 76 SK(SK_PAGE_UP),0, A_B_SCREEN, 77 'z',0, A_F_WINDOW, 78 'w',0, A_B_WINDOW, 79 ESC,' ',0, A_FF_SCREEN, 80 'F',0, A_F_FOREVER, 81 ESC,'F',0, A_F_UNTIL_HILITE, 82 'R',0, A_FREPAINT, 83 'r',0, A_REPAINT, 84 CONTROL('R'),0, A_REPAINT, 85 CONTROL('L'),0, A_REPAINT, 86 ESC,'u',0, A_UNDO_SEARCH, 87 'g',0, A_GOLINE, 88 SK(SK_HOME),0, A_GOLINE, 89 '<',0, A_GOLINE, 90 ESC,'<',0, A_GOLINE, 91 'p',0, A_PERCENT, 92 '%',0, A_PERCENT, 93 ESC,'[',0, A_LSHIFT, 94 ESC,']',0, A_RSHIFT, 95 ESC,'(',0, A_LSHIFT, 96 ESC,')',0, A_RSHIFT, 97 SK(SK_RIGHT_ARROW),0, A_RSHIFT, 98 SK(SK_LEFT_ARROW),0, A_LSHIFT, 99 '{',0, A_F_BRACKET|A_EXTRA, '{','}',0, 100 '}',0, A_B_BRACKET|A_EXTRA, '{','}',0, 101 '(',0, A_F_BRACKET|A_EXTRA, '(',')',0, 102 ')',0, A_B_BRACKET|A_EXTRA, '(',')',0, 103 '[',0, A_F_BRACKET|A_EXTRA, '[',']',0, 104 ']',0, A_B_BRACKET|A_EXTRA, '[',']',0, 105 ESC,CONTROL('F'),0, A_F_BRACKET, 106 ESC,CONTROL('B'),0, A_B_BRACKET, 107 'G',0, A_GOEND, 108 ESC,'G',0, A_GOEND_BUF, 109 ESC,'>',0, A_GOEND, 110 '>',0, A_GOEND, 111 SK(SK_END),0, A_GOEND, 112 'P',0, A_GOPOS, 113 114 '0',0, A_DIGIT, 115 '1',0, A_DIGIT, 116 '2',0, A_DIGIT, 117 '3',0, A_DIGIT, 118 '4',0, A_DIGIT, 119 '5',0, A_DIGIT, 120 '6',0, A_DIGIT, 121 '7',0, A_DIGIT, 122 '8',0, A_DIGIT, 123 '9',0, A_DIGIT, 124 '.',0, A_DIGIT, 125 126 '=',0, A_STAT, 127 CONTROL('G'),0, A_STAT, 128 ':','f',0, A_STAT, 129 '/',0, A_F_SEARCH, 130 '?',0, A_B_SEARCH, 131 ESC,'/',0, A_F_SEARCH|A_EXTRA, '*',0, 132 ESC,'?',0, A_B_SEARCH|A_EXTRA, '*',0, 133 'n',0, A_AGAIN_SEARCH, 134 ESC,'n',0, A_T_AGAIN_SEARCH, 135 'N',0, A_REVERSE_SEARCH, 136 ESC,'N',0, A_T_REVERSE_SEARCH, 137 '&',0, A_FILTER, 138 'm',0, A_SETMARK, 139 '\'',0, A_GOMARK, 140 CONTROL('X'),CONTROL('X'),0, A_GOMARK, 141 'E',0, A_EXAMINE, 142 ':','e',0, A_EXAMINE, 143 CONTROL('X'),CONTROL('V'),0, A_EXAMINE, 144 ':','n',0, A_NEXT_FILE, 145 ':','p',0, A_PREV_FILE, 146 't',0, A_NEXT_TAG, 147 'T',0, A_PREV_TAG, 148 ':','x',0, A_INDEX_FILE, 149 ':','d',0, A_REMOVE_FILE, 150 '-',0, A_OPT_TOGGLE, 151 ':','t',0, A_OPT_TOGGLE|A_EXTRA, 't',0, 152 's',0, A_OPT_TOGGLE|A_EXTRA, 'o',0, 153 '_',0, A_DISP_OPTION, 154 '|',0, A_PIPE, 155 'v',0, A_VISUAL, 156 '!',0, A_SHELL, 157 '+',0, A_FIRSTCMD, 158 159 'H',0, A_HELP, 160 'h',0, A_HELP, 161 SK(SK_F1),0, A_HELP, 162 'V',0, A_VERSION, 163 'q',0, A_QUIT, 164 'Q',0, A_QUIT, 165 ':','q',0, A_QUIT, 166 ':','Q',0, A_QUIT, 167 'Z','Z',0, A_QUIT 168 }; 169 170 static unsigned char edittable[] = 171 { 172 '\t',0, EC_F_COMPLETE, /* TAB */ 173 '\17',0, EC_B_COMPLETE, /* BACKTAB */ 174 SK(SK_BACKTAB),0, EC_B_COMPLETE, /* BACKTAB */ 175 ESC,'\t',0, EC_B_COMPLETE, /* ESC TAB */ 176 CONTROL('L'),0, EC_EXPAND, /* CTRL-L */ 177 CONTROL('V'),0, EC_LITERAL, /* BACKSLASH */ 178 CONTROL('A'),0, EC_LITERAL, /* BACKSLASH */ 179 ESC,'l',0, EC_RIGHT, /* ESC l */ 180 SK(SK_RIGHT_ARROW),0, EC_RIGHT, /* RIGHTARROW */ 181 ESC,'h',0, EC_LEFT, /* ESC h */ 182 SK(SK_LEFT_ARROW),0, EC_LEFT, /* LEFTARROW */ 183 ESC,'b',0, EC_W_LEFT, /* ESC b */ 184 ESC,SK(SK_LEFT_ARROW),0, EC_W_LEFT, /* ESC LEFTARROW */ 185 SK(SK_CTL_LEFT_ARROW),0, EC_W_LEFT, /* CTRL-LEFTARROW */ 186 ESC,'w',0, EC_W_RIGHT, /* ESC w */ 187 ESC,SK(SK_RIGHT_ARROW),0, EC_W_RIGHT, /* ESC RIGHTARROW */ 188 SK(SK_CTL_RIGHT_ARROW),0, EC_W_RIGHT, /* CTRL-RIGHTARROW */ 189 ESC,'i',0, EC_INSERT, /* ESC i */ 190 SK(SK_INSERT),0, EC_INSERT, /* INSERT */ 191 ESC,'x',0, EC_DELETE, /* ESC x */ 192 SK(SK_DELETE),0, EC_DELETE, /* DELETE */ 193 ESC,'X',0, EC_W_DELETE, /* ESC X */ 194 ESC,SK(SK_DELETE),0, EC_W_DELETE, /* ESC DELETE */ 195 SK(SK_CTL_DELETE),0, EC_W_DELETE, /* CTRL-DELETE */ 196 SK(SK_CTL_BACKSPACE),0, EC_W_BACKSPACE, /* CTRL-BACKSPACE */ 197 ESC,'\b',0, EC_W_BACKSPACE, /* ESC BACKSPACE */ 198 ESC,'0',0, EC_HOME, /* ESC 0 */ 199 SK(SK_HOME),0, EC_HOME, /* HOME */ 200 ESC,'$',0, EC_END, /* ESC $ */ 201 SK(SK_END),0, EC_END, /* END */ 202 ESC,'k',0, EC_UP, /* ESC k */ 203 SK(SK_UP_ARROW),0, EC_UP, /* UPARROW */ 204 ESC,'j',0, EC_DOWN, /* ESC j */ 205 SK(SK_DOWN_ARROW),0, EC_DOWN, /* DOWNARROW */ 206 CONTROL('G'),0, EC_ABORT, /* CTRL-G */ 207 }; 208 209 /* 210 * Structure to support a list of command tables. 211 */ 212 struct tablelist 213 { 214 struct tablelist *t_next; 215 char *t_start; 216 char *t_end; 217 }; 218 219 /* 220 * List of command tables and list of line-edit tables. 221 */ 222 static struct tablelist *list_fcmd_tables = NULL; 223 static struct tablelist *list_ecmd_tables = NULL; 224 static struct tablelist *list_var_tables = NULL; 225 static struct tablelist *list_sysvar_tables = NULL; 226 227 228 /* 229 * Expand special key abbreviations in a command table. 230 */ 231 static void 232 expand_special_keys(table, len) 233 char *table; 234 int len; 235 { 236 register char *fm; 237 register char *to; 238 register int a; 239 char *repl; 240 int klen; 241 242 for (fm = table; fm < table + len; ) 243 { 244 /* 245 * Rewrite each command in the table with any 246 * special key abbreviations expanded. 247 */ 248 for (to = fm; *fm != '\0'; ) 249 { 250 if (*fm != SK_SPECIAL_KEY) 251 { 252 *to++ = *fm++; 253 continue; 254 } 255 /* 256 * After SK_SPECIAL_KEY, next byte is the type 257 * of special key (one of the SK_* contants), 258 * and the byte after that is the number of bytes, 259 * N, reserved by the abbreviation (including the 260 * SK_SPECIAL_KEY and key type bytes). 261 * Replace all N bytes with the actual bytes 262 * output by the special key on this terminal. 263 */ 264 repl = special_key_str(fm[1]); 265 klen = fm[2] & 0377; 266 fm += klen; 267 if (repl == NULL || (int) strlen(repl) > klen) 268 repl = "\377"; 269 while (*repl != '\0') 270 *to++ = *repl++; 271 } 272 *to++ = '\0'; 273 /* 274 * Fill any unused bytes between end of command and 275 * the action byte with A_SKIP. 276 */ 277 while (to <= fm) 278 *to++ = A_SKIP; 279 fm++; 280 a = *fm++ & 0377; 281 if (a & A_EXTRA) 282 { 283 while (*fm++ != '\0') 284 continue; 285 } 286 } 287 } 288 289 /* 290 * Initialize the command lists. 291 */ 292 public void 293 init_cmds() 294 { 295 /* 296 * Add the default command tables. 297 */ 298 add_fcmd_table((char*)cmdtable, sizeof(cmdtable)); 299 add_ecmd_table((char*)edittable, sizeof(edittable)); 300 #if USERFILE 301 /* 302 * For backwards compatibility, 303 * try to add tables in the OLD system lesskey file. 304 */ 305 #ifdef BINDIR 306 add_hometable(NULL, BINDIR "/.sysless", 1); 307 #endif 308 /* 309 * Try to add the tables in the system lesskey file. 310 */ 311 add_hometable("LESSKEY_SYSTEM", LESSKEYFILE_SYS, 1); 312 /* 313 * Try to add the tables in the standard lesskey file "$HOME/.less". 314 */ 315 add_hometable("LESSKEY", LESSKEYFILE, 0); 316 #endif 317 } 318 319 /* 320 * Add a command table. 321 */ 322 static int 323 add_cmd_table(tlist, buf, len) 324 struct tablelist **tlist; 325 char *buf; 326 int len; 327 { 328 register struct tablelist *t; 329 330 if (len == 0) 331 return (0); 332 /* 333 * Allocate a tablelist structure, initialize it, 334 * and link it into the list of tables. 335 */ 336 if ((t = (struct tablelist *) 337 calloc(1, sizeof(struct tablelist))) == NULL) 338 { 339 return (-1); 340 } 341 expand_special_keys(buf, len); 342 t->t_start = buf; 343 t->t_end = buf + len; 344 t->t_next = *tlist; 345 *tlist = t; 346 return (0); 347 } 348 349 /* 350 * Add a command table. 351 */ 352 public void 353 add_fcmd_table(buf, len) 354 char *buf; 355 int len; 356 { 357 if (add_cmd_table(&list_fcmd_tables, buf, len) < 0) 358 error("Warning: some commands disabled", NULL_PARG); 359 } 360 361 /* 362 * Add an editing command table. 363 */ 364 public void 365 add_ecmd_table(buf, len) 366 char *buf; 367 int len; 368 { 369 if (add_cmd_table(&list_ecmd_tables, buf, len) < 0) 370 error("Warning: some edit commands disabled", NULL_PARG); 371 } 372 373 /* 374 * Add an environment variable table. 375 */ 376 static void 377 add_var_table(tlist, buf, len) 378 struct tablelist **tlist; 379 char *buf; 380 int len; 381 { 382 if (add_cmd_table(tlist, buf, len) < 0) 383 error("Warning: environment variables from lesskey file unavailable", NULL_PARG); 384 } 385 386 /* 387 * Search a single command table for the command string in cmd. 388 */ 389 static int 390 cmd_search(cmd, table, endtable, sp) 391 char *cmd; 392 char *table; 393 char *endtable; 394 char **sp; 395 { 396 register char *p; 397 register char *q; 398 register int a; 399 400 *sp = NULL; 401 for (p = table, q = cmd; p < endtable; p++, q++) 402 { 403 if (*p == *q) 404 { 405 /* 406 * Current characters match. 407 * If we're at the end of the string, we've found it. 408 * Return the action code, which is the character 409 * after the null at the end of the string 410 * in the command table. 411 */ 412 if (*p == '\0') 413 { 414 a = *++p & 0377; 415 while (a == A_SKIP) 416 a = *++p & 0377; 417 if (a == A_END_LIST) 418 { 419 /* 420 * We get here only if the original 421 * cmd string passed in was empty (""). 422 * I don't think that can happen, 423 * but just in case ... 424 */ 425 return (A_UINVALID); 426 } 427 /* 428 * Check for an "extra" string. 429 */ 430 if (a & A_EXTRA) 431 { 432 *sp = ++p; 433 a &= ~A_EXTRA; 434 } 435 return (a); 436 } 437 } else if (*q == '\0') 438 { 439 /* 440 * Hit the end of the user's command, 441 * but not the end of the string in the command table. 442 * The user's command is incomplete. 443 */ 444 return (A_PREFIX); 445 } else 446 { 447 /* 448 * Not a match. 449 * Skip ahead to the next command in the 450 * command table, and reset the pointer 451 * to the beginning of the user's command. 452 */ 453 if (*p == '\0' && p[1] == A_END_LIST) 454 { 455 /* 456 * A_END_LIST is a special marker that tells 457 * us to abort the cmd search. 458 */ 459 return (A_UINVALID); 460 } 461 while (*p++ != '\0') 462 continue; 463 while (*p == A_SKIP) 464 p++; 465 if (*p & A_EXTRA) 466 while (*++p != '\0') 467 continue; 468 q = cmd-1; 469 } 470 } 471 /* 472 * No match found in the entire command table. 473 */ 474 return (A_INVALID); 475 } 476 477 /* 478 * Decode a command character and return the associated action. 479 * The "extra" string, if any, is returned in sp. 480 */ 481 static int 482 cmd_decode(tlist, cmd, sp) 483 struct tablelist *tlist; 484 char *cmd; 485 char **sp; 486 { 487 register struct tablelist *t; 488 register int action = A_INVALID; 489 490 /* 491 * Search thru all the command tables. 492 * Stop when we find an action which is not A_INVALID. 493 */ 494 for (t = tlist; t != NULL; t = t->t_next) 495 { 496 action = cmd_search(cmd, t->t_start, t->t_end, sp); 497 if (action != A_INVALID) 498 break; 499 } 500 if (action == A_UINVALID) 501 action = A_INVALID; 502 return (action); 503 } 504 505 /* 506 * Decode a command from the cmdtables list. 507 */ 508 public int 509 fcmd_decode(cmd, sp) 510 char *cmd; 511 char **sp; 512 { 513 return (cmd_decode(list_fcmd_tables, cmd, sp)); 514 } 515 516 /* 517 * Decode a command from the edittables list. 518 */ 519 public int 520 ecmd_decode(cmd, sp) 521 char *cmd; 522 char **sp; 523 { 524 return (cmd_decode(list_ecmd_tables, cmd, sp)); 525 } 526 527 /* 528 * Get the value of an environment variable. 529 * Looks first in the lesskey file, then in the real environment. 530 */ 531 public char * 532 lgetenv(var) 533 char *var; 534 { 535 int a; 536 char *s; 537 538 a = cmd_decode(list_var_tables, var, &s); 539 if (a == EV_OK) 540 return (s); 541 s = getenv(var); 542 if (s != NULL && *s != '\0') 543 return (s); 544 a = cmd_decode(list_sysvar_tables, var, &s); 545 if (a == EV_OK) 546 return (s); 547 return (NULL); 548 } 549 550 #if USERFILE 551 /* 552 * Get an "integer" from a lesskey file. 553 * Integers are stored in a funny format: 554 * two bytes, low order first, in radix KRADIX. 555 */ 556 static int 557 gint(sp) 558 char **sp; 559 { 560 int n; 561 562 n = *(*sp)++; 563 n += *(*sp)++ * KRADIX; 564 return (n); 565 } 566 567 /* 568 * Process an old (pre-v241) lesskey file. 569 */ 570 static int 571 old_lesskey(buf, len) 572 char *buf; 573 int len; 574 { 575 /* 576 * Old-style lesskey file. 577 * The file must end with either 578 * ...,cmd,0,action 579 * or ...,cmd,0,action|A_EXTRA,string,0 580 * So the last byte or the second to last byte must be zero. 581 */ 582 if (buf[len-1] != '\0' && buf[len-2] != '\0') 583 return (-1); 584 add_fcmd_table(buf, len); 585 return (0); 586 } 587 588 /* 589 * Process a new (post-v241) lesskey file. 590 */ 591 static int 592 new_lesskey(buf, len, sysvar) 593 char *buf; 594 int len; 595 int sysvar; 596 { 597 char *p; 598 register int c; 599 register int n; 600 601 /* 602 * New-style lesskey file. 603 * Extract the pieces. 604 */ 605 if (buf[len-3] != C0_END_LESSKEY_MAGIC || 606 buf[len-2] != C1_END_LESSKEY_MAGIC || 607 buf[len-1] != C2_END_LESSKEY_MAGIC) 608 return (-1); 609 p = buf + 4; 610 for (;;) 611 { 612 c = *p++; 613 switch (c) 614 { 615 case CMD_SECTION: 616 n = gint(&p); 617 add_fcmd_table(p, n); 618 p += n; 619 break; 620 case EDIT_SECTION: 621 n = gint(&p); 622 add_ecmd_table(p, n); 623 p += n; 624 break; 625 case VAR_SECTION: 626 n = gint(&p); 627 add_var_table((sysvar) ? 628 &list_sysvar_tables : &list_var_tables, p, n); 629 p += n; 630 break; 631 case END_SECTION: 632 return (0); 633 default: 634 /* 635 * Unrecognized section type. 636 */ 637 return (-1); 638 } 639 } 640 } 641 642 /* 643 * Set up a user command table, based on a "lesskey" file. 644 */ 645 public int 646 lesskey(filename, sysvar) 647 char *filename; 648 int sysvar; 649 { 650 register char *buf; 651 register POSITION len; 652 register long n; 653 register int f; 654 655 if (secure) 656 return (1); 657 /* 658 * Try to open the lesskey file. 659 */ 660 filename = shell_unquote(filename); 661 f = open(filename, OPEN_READ); 662 free(filename); 663 if (f < 0) 664 return (1); 665 666 /* 667 * Read the file into a buffer. 668 * We first figure out the size of the file and allocate space for it. 669 * {{ Minimal error checking is done here. 670 * A garbage .less file will produce strange results. 671 * To avoid a large amount of error checking code here, we 672 * rely on the lesskey program to generate a good .less file. }} 673 */ 674 len = filesize(f); 675 if (len == NULL_POSITION || len < 3) 676 { 677 /* 678 * Bad file (valid file must have at least 3 chars). 679 */ 680 close(f); 681 return (-1); 682 } 683 if ((buf = (char *) calloc((int)len, sizeof(char))) == NULL) 684 { 685 close(f); 686 return (-1); 687 } 688 if (lseek(f, (off_t)0, SEEK_SET) == BAD_LSEEK) 689 { 690 free(buf); 691 close(f); 692 return (-1); 693 } 694 n = read(f, buf, (unsigned int) len); 695 close(f); 696 if (n != len) 697 { 698 free(buf); 699 return (-1); 700 } 701 702 /* 703 * Figure out if this is an old-style (before version 241) 704 * or new-style lesskey file format. 705 */ 706 if (buf[0] != C0_LESSKEY_MAGIC || buf[1] != C1_LESSKEY_MAGIC || 707 buf[2] != C2_LESSKEY_MAGIC || buf[3] != C3_LESSKEY_MAGIC) 708 return (old_lesskey(buf, (int)len)); 709 return (new_lesskey(buf, (int)len, sysvar)); 710 } 711 712 /* 713 * Add the standard lesskey file "$HOME/.less" 714 */ 715 public void 716 add_hometable(envname, def_filename, sysvar) 717 char *envname; 718 char *def_filename; 719 int sysvar; 720 { 721 char *filename; 722 PARG parg; 723 724 if (envname != NULL && (filename = lgetenv(envname)) != NULL) 725 filename = save(filename); 726 else if (sysvar) 727 filename = save(def_filename); 728 else 729 filename = homefile(def_filename); 730 if (filename == NULL) 731 return; 732 if (lesskey(filename, sysvar) < 0) 733 { 734 parg.p_string = filename; 735 error("Cannot use lesskey file \"%s\"", &parg); 736 } 737 free(filename); 738 } 739 #endif 740 741 /* 742 * See if a char is a special line-editing command. 743 */ 744 public int 745 editchar(c, flags) 746 int c; 747 int flags; 748 { 749 int action; 750 int nch; 751 char *s; 752 char usercmd[MAX_CMDLEN+1]; 753 754 /* 755 * An editing character could actually be a sequence of characters; 756 * for example, an escape sequence sent by pressing the uparrow key. 757 * To match the editing string, we use the command decoder 758 * but give it the edit-commands command table 759 * This table is constructed to match the user's keyboard. 760 */ 761 if (c == erase_char || c == erase2_char) 762 return (EC_BACKSPACE); 763 if (c == kill_char) 764 return (EC_LINEKILL); 765 766 /* 767 * Collect characters in a buffer. 768 * Start with the one we have, and get more if we need them. 769 */ 770 nch = 0; 771 do { 772 if (nch > 0) 773 c = getcc(); 774 usercmd[nch] = c; 775 usercmd[nch+1] = '\0'; 776 nch++; 777 action = ecmd_decode(usercmd, &s); 778 } while (action == A_PREFIX); 779 780 if (flags & EC_NORIGHTLEFT) 781 { 782 switch (action) 783 { 784 case EC_RIGHT: 785 case EC_LEFT: 786 action = A_INVALID; 787 break; 788 } 789 } 790 #if CMD_HISTORY 791 if (flags & EC_NOHISTORY) 792 { 793 /* 794 * The caller says there is no history list. 795 * Reject any history-manipulation action. 796 */ 797 switch (action) 798 { 799 case EC_UP: 800 case EC_DOWN: 801 action = A_INVALID; 802 break; 803 } 804 } 805 #endif 806 #if TAB_COMPLETE_FILENAME 807 if (flags & EC_NOCOMPLETE) 808 { 809 /* 810 * The caller says we don't want any filename completion cmds. 811 * Reject them. 812 */ 813 switch (action) 814 { 815 case EC_F_COMPLETE: 816 case EC_B_COMPLETE: 817 case EC_EXPAND: 818 action = A_INVALID; 819 break; 820 } 821 } 822 #endif 823 if ((flags & EC_PEEK) || action == A_INVALID) 824 { 825 /* 826 * We're just peeking, or we didn't understand the command. 827 * Unget all the characters we read in the loop above. 828 * This does NOT include the original character that was 829 * passed in as a parameter. 830 */ 831 while (nch > 1) 832 { 833 ungetcc(usercmd[--nch]); 834 } 835 } else 836 { 837 if (s != NULL) 838 ungetsc(s); 839 } 840 return action; 841 } 842 843