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