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