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