1 /* 2 * Copyright (C) 1984-2012 Mark Nudelman 3 * Modified for use with illumos by Garrett D'Amore. 4 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Less License, as specified in the README file. 8 * 9 * For more information, see the README file. 10 */ 11 12 /* 13 * lesskey [-o output] [input] 14 * 15 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 16 * 17 * Make a .less file. 18 * If no input file is specified, standard input is used. 19 * If no output file is specified, $HOME/.less is used. 20 * 21 * The .less file is used to specify (to "less") user-defined 22 * key bindings. Basically any sequence of 1 to MAX_CMDLEN 23 * keystrokes may be bound to an existing less function. 24 * 25 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 26 * 27 * The input file is an ascii file consisting of a 28 * sequence of lines of the form: 29 * string <whitespace> action [chars] <newline> 30 * 31 * "string" is a sequence of command characters which form 32 * the new user-defined command. The command 33 * characters may be: 34 * 1. The actual character itself. 35 * 2. A character preceded by ^ to specify a 36 * control character (e.g. ^X means control-X). 37 * 3. A backslash followed by one to three octal digits 38 * to specify a character by its octal value. 39 * 4. A backslash followed by b, e, n, r or t 40 * to specify \b, ESC, \n, \r or \t, respectively. 41 * 5. Any character (other than those mentioned above) preceded 42 * by a \ to specify the character itself (characters which 43 * must be preceded by \ include ^, \, and whitespace. 44 * "action" is the name of a "less" action, from the table below. 45 * "chars" is an optional sequence of characters which is treated 46 * as keyboard input after the command is executed. 47 * 48 * Blank lines and lines which start with # are ignored, 49 * except for the special control lines: 50 * #command Signals the beginning of the command 51 * keys section. 52 * #line-edit Signals the beginning of the line-editing 53 * keys section. 54 * #env Signals the beginning of the environment 55 * variable section. 56 * #stop Stops command parsing in less; 57 * causes all default keys to be disabled. 58 * 59 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 60 * 61 * The output file is a non-ascii file, consisting of a header, 62 * one or more sections, and a trailer. 63 * Each section begins with a section header, a section length word 64 * and the section data. Normally there are three sections: 65 * CMD_SECTION Definition of command keys. 66 * EDIT_SECTION Definition of editing keys. 67 * END_SECTION A special section header, with no 68 * length word or section data. 69 * 70 * Section data consists of zero or more byte sequences of the form: 71 * string <0> <action> 72 * or 73 * string <0> <action|A_EXTRA> chars <0> 74 * 75 * "string" is the command string. 76 * "<0>" is one null byte. 77 * "<action>" is one byte containing the action code (the A_xxx value). 78 * If action is ORed with A_EXTRA, the action byte is followed 79 * by the null-terminated "chars" string. 80 * 81 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 82 */ 83 84 #include <err.h> 85 86 #include "cmd.h" 87 #include "less.h" 88 #include "lesskey.h" 89 90 struct cmdname { 91 char *cn_name; 92 int cn_action; 93 }; 94 95 static void lkerr(char *); 96 97 struct cmdname cmdnames[] = { 98 { "back-bracket", A_B_BRACKET }, 99 { "back-line", A_B_LINE }, 100 { "back-line-force", A_BF_LINE }, 101 { "back-screen", A_B_SCREEN }, 102 { "back-scroll", A_B_SCROLL }, 103 { "back-search", A_B_SEARCH }, 104 { "back-window", A_B_WINDOW }, 105 { "debug", A_DEBUG }, 106 { "digit", A_DIGIT }, 107 { "display-flag", A_DISP_OPTION }, 108 { "display-option", A_DISP_OPTION }, 109 { "end", A_GOEND }, 110 { "examine", A_EXAMINE }, 111 { "filter", A_FILTER }, 112 { "first-cmd", A_FIRSTCMD }, 113 { "firstcmd", A_FIRSTCMD }, 114 { "flush-repaint", A_FREPAINT }, 115 { "forw-bracket", A_F_BRACKET }, 116 { "forw-forever", A_F_FOREVER }, 117 { "forw-until-hilite", A_F_UNTIL_HILITE }, 118 { "forw-line", A_F_LINE }, 119 { "forw-line-force", A_FF_LINE }, 120 { "forw-screen", A_F_SCREEN }, 121 { "forw-screen-force", A_FF_SCREEN }, 122 { "forw-scroll", A_F_SCROLL }, 123 { "forw-search", A_F_SEARCH }, 124 { "forw-skip", A_F_SKIP }, 125 { "forw-window", A_F_WINDOW }, 126 { "goto-end", A_GOEND }, 127 { "goto-line", A_GOLINE }, 128 { "goto-mark", A_GOMARK }, 129 { "help", A_HELP }, 130 { "index-file", A_INDEX_FILE }, 131 { "invalid", A_UINVALID }, 132 { "left-scroll", A_LSHIFT }, 133 { "next-file", A_NEXT_FILE }, 134 { "next-tag", A_NEXT_TAG }, 135 { "noaction", A_NOACTION }, 136 { "percent", A_PERCENT }, 137 { "pipe", A_PIPE }, 138 { "prev-file", A_PREV_FILE }, 139 { "prev-tag", A_PREV_TAG }, 140 { "quit", A_QUIT }, 141 { "remove-file", A_REMOVE_FILE }, 142 { "repaint", A_REPAINT }, 143 { "repaint-flush", A_FREPAINT }, 144 { "repeat-search", A_AGAIN_SEARCH }, 145 { "repeat-search-all", A_T_AGAIN_SEARCH }, 146 { "reverse-search", A_REVERSE_SEARCH }, 147 { "reverse-search-all", A_T_REVERSE_SEARCH }, 148 { "right-scroll", A_RSHIFT }, 149 { "set-mark", A_SETMARK }, 150 { "status", A_STAT }, 151 { "toggle-flag", A_OPT_TOGGLE }, 152 { "toggle-option", A_OPT_TOGGLE }, 153 { "undo-hilite", A_UNDO_SEARCH }, 154 { "version", A_VERSION }, 155 { "visual", A_VISUAL }, 156 { NULL, 0 } 157 }; 158 159 struct cmdname editnames[] = { 160 { "back-complete", EC_B_COMPLETE }, 161 { "backspace", EC_BACKSPACE }, 162 { "delete", EC_DELETE }, 163 { "down", EC_DOWN }, 164 { "end", EC_END }, 165 { "expand", EC_EXPAND }, 166 { "forw-complete", EC_F_COMPLETE }, 167 { "home", EC_HOME }, 168 { "insert", EC_INSERT }, 169 { "invalid", EC_UINVALID }, 170 { "kill-line", EC_LINEKILL }, 171 { "abort", EC_ABORT }, 172 { "left", EC_LEFT }, 173 { "literal", EC_LITERAL }, 174 { "right", EC_RIGHT }, 175 { "up", EC_UP }, 176 { "word-backspace", EC_W_BACKSPACE }, 177 { "word-delete", EC_W_DELETE }, 178 { "word-left", EC_W_LEFT }, 179 { "word-right", EC_W_RIGHT }, 180 { NULL, 0 } 181 }; 182 183 struct table { 184 struct cmdname *names; 185 char *pbuffer; 186 char buffer[MAX_USERCMD]; 187 }; 188 189 struct table cmdtable; 190 struct table edittable; 191 struct table vartable; 192 struct table *currtable = &cmdtable; 193 194 char fileheader[] = { 195 C0_LESSKEY_MAGIC, 196 C1_LESSKEY_MAGIC, 197 C2_LESSKEY_MAGIC, 198 C3_LESSKEY_MAGIC 199 }; 200 char filetrailer[] = { 201 C0_END_LESSKEY_MAGIC, 202 C1_END_LESSKEY_MAGIC, 203 C2_END_LESSKEY_MAGIC 204 }; 205 char cmdsection[1] = { CMD_SECTION }; 206 char editsection[1] = { EDIT_SECTION }; 207 char varsection[1] = { VAR_SECTION }; 208 char endsection[1] = { END_SECTION }; 209 210 char *infile = NULL; 211 char *outfile = NULL; 212 213 int linenum; 214 int errors; 215 216 extern char version[]; 217 218 static void 219 usage(void) 220 { 221 (void) fprintf(stderr, "usage: lesskey [-o output] [input]\n"); 222 exit(1); 223 } 224 225 static char * 226 mkpathname(char *dirname, char *filename) 227 { 228 char *pathname; 229 size_t len; 230 231 len = strlen(dirname) + strlen(filename) + 2; 232 pathname = calloc(1, len); 233 if (pathname == NULL) { 234 fprintf(stderr, "mkpathname: out of memory\n"); 235 exit(1); 236 } 237 (void) snprintf(pathname, len, "%s/%s", dirname, filename); 238 return (pathname); 239 } 240 241 /* 242 * Figure out the name of a default file (in the user's HOME directory). 243 */ 244 char * 245 homefile(char *filename) 246 { 247 char *p; 248 char *pathname; 249 250 if ((p = getenv("HOME")) != NULL && *p != '\0') { 251 pathname = mkpathname(p, filename); 252 } else { 253 (void) fprintf(stderr, "cannot find $HOME - " 254 "using current directory\n"); 255 pathname = mkpathname(".", filename); 256 } 257 return (pathname); 258 } 259 260 /* 261 * Parse command line arguments. 262 */ 263 static void 264 parse_args(int argc, char **argv) 265 { 266 char *arg; 267 268 outfile = NULL; 269 while (--argc > 0) { 270 arg = *++argv; 271 if (arg[0] != '-') 272 /* Arg does not start with "-"; it's not an option. */ 273 break; 274 if (arg[1] == '\0') 275 /* "-" means standard input. */ 276 break; 277 if (arg[1] == '-' && arg[2] == '\0') { 278 /* "--" means end of options. */ 279 argc--; 280 argv++; 281 break; 282 } 283 switch (arg[1]) { 284 case '-': 285 if (strncmp(arg, "--output", 8) == 0) { 286 if (arg[8] == '\0') 287 outfile = &arg[8]; 288 else if (arg[8] == '=') 289 outfile = &arg[9]; 290 else 291 usage(); 292 goto opt_o; 293 } 294 if (strcmp(arg, "--version") == 0) { 295 goto opt_V; 296 } 297 usage(); 298 break; 299 case 'o': 300 outfile = &argv[0][2]; 301 opt_o: 302 if (*outfile == '\0') { 303 if (--argc <= 0) 304 usage(); 305 outfile = *(++argv); 306 } 307 break; 308 case 'V': 309 opt_V: 310 (void) printf("lesskey version %s\n", version); 311 exit(0); 312 default: 313 usage(); 314 } 315 } 316 if (argc > 1) 317 usage(); 318 /* 319 * Open the input file, or use DEF_LESSKEYINFILE if none specified. 320 */ 321 if (argc > 0) 322 infile = *argv; 323 else 324 infile = homefile(DEF_LESSKEYINFILE); 325 } 326 327 /* 328 * Initialize data structures. 329 */ 330 static void 331 init_tables(void) 332 { 333 cmdtable.names = cmdnames; 334 cmdtable.pbuffer = cmdtable.buffer; 335 336 edittable.names = editnames; 337 edittable.pbuffer = edittable.buffer; 338 339 vartable.names = NULL; 340 vartable.pbuffer = vartable.buffer; 341 } 342 343 /* 344 * Parse one character of a string. 345 */ 346 static char * 347 tstr(char **pp, int xlate) 348 { 349 char *p; 350 char ch; 351 int i; 352 static char buf[10]; 353 static char tstr_control_k[] = 354 { SK_SPECIAL_KEY, SK_CONTROL_K, 6, 1, 1, 1, '\0' }; 355 356 p = *pp; 357 switch (*p) { 358 case '\\': 359 ++p; 360 switch (*p) { 361 case '0': case '1': case '2': case '3': 362 case '4': case '5': case '6': case '7': 363 /* 364 * Parse an octal number. 365 */ 366 ch = 0; 367 i = 0; 368 do 369 ch = 8*ch + (*p - '0'); 370 while (*++p >= '0' && *p <= '7' && ++i < 3) 371 ; 372 *pp = p; 373 if (xlate && ch == CONTROL('K')) 374 return (tstr_control_k); 375 buf[0] = ch; 376 buf[1] = '\0'; 377 return (buf); 378 case 'b': 379 *pp = p+1; 380 return ("\b"); 381 case 'e': 382 *pp = p+1; 383 buf[0] = ESC; 384 buf[1] = '\0'; 385 return (buf); 386 case 'n': 387 *pp = p+1; 388 return ("\n"); 389 case 'r': 390 *pp = p+1; 391 return ("\r"); 392 case 't': 393 *pp = p+1; 394 return ("\t"); 395 case 'k': 396 if (xlate) { 397 switch (*++p) { 398 case 'u': ch = SK_UP_ARROW; break; 399 case 'd': ch = SK_DOWN_ARROW; break; 400 case 'r': ch = SK_RIGHT_ARROW; break; 401 case 'l': ch = SK_LEFT_ARROW; break; 402 case 'U': ch = SK_PAGE_UP; break; 403 case 'D': ch = SK_PAGE_DOWN; break; 404 case 'h': ch = SK_HOME; break; 405 case 'e': ch = SK_END; break; 406 case 'x': ch = SK_DELETE; break; 407 default: 408 lkerr("illegal char after \\k"); 409 *pp = p+1; 410 return (""); 411 } 412 *pp = p+1; 413 buf[0] = SK_SPECIAL_KEY; 414 buf[1] = ch; 415 buf[2] = 6; 416 buf[3] = 1; 417 buf[4] = 1; 418 buf[5] = 1; 419 buf[6] = '\0'; 420 return (buf); 421 } 422 /* FALLTHRU */ 423 default: 424 /* 425 * Backslash followed by any other char 426 * just means that char. 427 */ 428 *pp = p+1; 429 buf[0] = *p; 430 buf[1] = '\0'; 431 if (xlate && buf[0] == CONTROL('K')) 432 return (tstr_control_k); 433 return (buf); 434 } 435 case '^': 436 /* 437 * Caret means CONTROL. 438 */ 439 *pp = p+2; 440 buf[0] = CONTROL(p[1]); 441 buf[1] = '\0'; 442 if (buf[0] == CONTROL('K')) 443 return (tstr_control_k); 444 return (buf); 445 } 446 *pp = p+1; 447 buf[0] = *p; 448 buf[1] = '\0'; 449 if (xlate && buf[0] == CONTROL('K')) 450 return (tstr_control_k); 451 return (buf); 452 } 453 454 /* 455 * Skip leading spaces in a string. 456 */ 457 char * 458 skipsp(char *s) 459 { 460 while (*s == ' ' || *s == '\t') 461 s++; 462 return (s); 463 } 464 465 /* 466 * Skip non-space characters in a string. 467 */ 468 static char * 469 skipnsp(char *s) 470 { 471 while (*s != '\0' && *s != ' ' && *s != '\t') 472 s++; 473 return (s); 474 } 475 476 /* 477 * Clean up an input line: 478 * strip off the trailing newline & any trailing # comment. 479 */ 480 static char * 481 clean_line(char *s) 482 { 483 int i; 484 485 s = skipsp(s); 486 for (i = 0; s[i] != '\n' && s[i] != '\r' && s[i] != '\0'; i++) 487 if (s[i] == '#' && (i == 0 || s[i-1] != '\\')) 488 break; 489 s[i] = '\0'; 490 return (s); 491 } 492 493 /* 494 * Add a byte to the output command table. 495 */ 496 static void 497 add_cmd_char(int c) 498 { 499 if (currtable->pbuffer >= currtable->buffer + MAX_USERCMD) { 500 lkerr("too many commands"); 501 exit(1); 502 } 503 *(currtable->pbuffer)++ = (char)c; 504 } 505 506 /* 507 * Add a string to the output command table. 508 */ 509 static void 510 add_cmd_str(char *s) 511 { 512 for (; *s != '\0'; s++) 513 add_cmd_char(*s); 514 } 515 516 /* 517 * See if we have a special "control" line. 518 */ 519 static int 520 control_line(char *s) 521 { 522 #define PREFIX(str, pat) (strncmp(str, pat, strlen(pat)) == 0) 523 524 if (PREFIX(s, "#line-edit")) { 525 currtable = &edittable; 526 return (1); 527 } 528 if (PREFIX(s, "#command")) { 529 currtable = &cmdtable; 530 return (1); 531 } 532 if (PREFIX(s, "#env")) { 533 currtable = &vartable; 534 return (1); 535 } 536 if (PREFIX(s, "#stop")) { 537 add_cmd_char('\0'); 538 add_cmd_char(A_END_LIST); 539 return (1); 540 } 541 return (0); 542 } 543 544 /* 545 * Output some bytes. 546 */ 547 static void 548 fputbytes(FILE *fd, char *buf, int len) 549 { 550 while (len-- > 0) { 551 (void) fwrite(buf, sizeof (char), 1, fd); 552 buf++; 553 } 554 } 555 556 /* 557 * Output an integer, in special KRADIX form. 558 */ 559 static void 560 fputint(FILE *fd, unsigned int val) 561 { 562 char c; 563 564 if (val >= KRADIX*KRADIX) { 565 (void) fprintf(stderr, "error: integer too big (%d > %d)\n", 566 val, KRADIX*KRADIX); 567 exit(1); 568 } 569 c = val % KRADIX; 570 (void) fwrite(&c, sizeof (char), 1, fd); 571 c = val / KRADIX; 572 (void) fwrite(&c, sizeof (char), 1, fd); 573 } 574 575 /* 576 * Find an action, given the name of the action. 577 */ 578 static int 579 findaction(char *actname) 580 { 581 int i; 582 583 for (i = 0; currtable->names[i].cn_name != NULL; i++) 584 if (strcmp(currtable->names[i].cn_name, actname) == 0) 585 return (currtable->names[i].cn_action); 586 lkerr("unknown action"); 587 return (A_INVALID); 588 } 589 590 static void 591 lkerr(char *s) 592 { 593 (void) fprintf(stderr, "line %d: %s\n", linenum, s); 594 errors++; 595 } 596 597 598 static void 599 parse_cmdline(char *p) 600 { 601 int cmdlen; 602 char *actname; 603 int action; 604 char *s; 605 char c; 606 607 /* 608 * Parse the command string and store it in the current table. 609 */ 610 cmdlen = 0; 611 do { 612 s = tstr(&p, 1); 613 cmdlen += strlen(s); 614 if (cmdlen > MAX_CMDLEN) 615 lkerr("command too long"); 616 else 617 add_cmd_str(s); 618 } while (*p != ' ' && *p != '\t' && *p != '\0'); 619 /* 620 * Terminate the command string with a null byte. 621 */ 622 add_cmd_char('\0'); 623 624 /* 625 * Skip white space between the command string 626 * and the action name. 627 * Terminate the action name with a null byte. 628 */ 629 p = skipsp(p); 630 if (*p == '\0') { 631 lkerr("missing action"); 632 return; 633 } 634 actname = p; 635 p = skipnsp(p); 636 c = *p; 637 *p = '\0'; 638 639 /* 640 * Parse the action name and store it in the current table. 641 */ 642 action = findaction(actname); 643 644 /* 645 * See if an extra string follows the action name. 646 */ 647 *p = c; 648 p = skipsp(p); 649 if (*p == '\0') { 650 add_cmd_char(action); 651 } else { 652 /* 653 * OR the special value A_EXTRA into the action byte. 654 * Put the extra string after the action byte. 655 */ 656 add_cmd_char(action | A_EXTRA); 657 while (*p != '\0') 658 add_cmd_str(tstr(&p, 0)); 659 add_cmd_char('\0'); 660 } 661 } 662 663 static void 664 parse_varline(char *p) 665 { 666 char *s; 667 668 do { 669 s = tstr(&p, 0); 670 add_cmd_str(s); 671 } while (*p != ' ' && *p != '\t' && *p != '=' && *p != '\0'); 672 /* 673 * Terminate the variable name with a null byte. 674 */ 675 add_cmd_char('\0'); 676 677 p = skipsp(p); 678 if (*p++ != '=') { 679 lkerr("missing ="); 680 return; 681 } 682 683 add_cmd_char(EV_OK|A_EXTRA); 684 685 p = skipsp(p); 686 while (*p != '\0') { 687 s = tstr(&p, 0); 688 add_cmd_str(s); 689 } 690 add_cmd_char('\0'); 691 } 692 693 /* 694 * Parse a line from the lesskey file. 695 */ 696 static void 697 parse_line(char *line) 698 { 699 char *p; 700 701 /* 702 * See if it is a control line. 703 */ 704 if (control_line(line)) 705 return; 706 /* 707 * Skip leading white space. 708 * Replace the final newline with a null byte. 709 * Ignore blank lines and comments. 710 */ 711 p = clean_line(line); 712 if (*p == '\0') 713 return; 714 715 if (currtable == &vartable) 716 parse_varline(p); 717 else 718 parse_cmdline(p); 719 } 720 721 int 722 main(int argc, char **argv) 723 { 724 FILE *desc; 725 FILE *out; 726 char line[1024]; 727 728 if (pledge("stdio rpath wpath cpath", NULL) == -1) 729 err(1, "pledge"); 730 731 /* 732 * Process command line arguments. 733 */ 734 parse_args(argc, argv); 735 init_tables(); 736 737 /* 738 * Open the input file. 739 */ 740 if (strcmp(infile, "-") == 0) 741 desc = stdin; 742 else if ((desc = fopen(infile, "r")) == NULL) { 743 perror(infile); 744 usage(); 745 } 746 747 /* 748 * Read and parse the input file, one line at a time. 749 */ 750 errors = 0; 751 linenum = 0; 752 while (fgets(line, sizeof (line), desc) != NULL) { 753 ++linenum; 754 parse_line(line); 755 } 756 fclose(desc); 757 758 /* 759 * Write the output file. 760 * If no output file was specified, use "$HOME/.less" 761 */ 762 if (errors > 0) { 763 (void) fprintf(stderr, "%d errors; no output produced\n", 764 errors); 765 exit(1); 766 } 767 768 if (outfile == NULL) 769 outfile = getenv("LESSKEY"); 770 if (outfile == NULL) 771 outfile = homefile(LESSKEYFILE); 772 if ((out = fopen(outfile, "wb")) == NULL) { 773 perror(outfile); 774 exit(1); 775 } 776 777 /* File header */ 778 fputbytes(out, fileheader, sizeof (fileheader)); 779 780 /* Command key section */ 781 fputbytes(out, cmdsection, sizeof (cmdsection)); 782 fputint(out, cmdtable.pbuffer - cmdtable.buffer); 783 fputbytes(out, (char *)cmdtable.buffer, 784 cmdtable.pbuffer-cmdtable.buffer); 785 786 /* Edit key section */ 787 fputbytes(out, editsection, sizeof (editsection)); 788 fputint(out, edittable.pbuffer - edittable.buffer); 789 fputbytes(out, (char *)edittable.buffer, 790 edittable.pbuffer-edittable.buffer); 791 792 /* Environment variable section */ 793 fputbytes(out, varsection, sizeof (varsection)); 794 fputint(out, vartable.pbuffer - vartable.buffer); 795 fputbytes(out, (char *)vartable.buffer, 796 vartable.pbuffer-vartable.buffer); 797 798 /* File trailer */ 799 fputbytes(out, endsection, sizeof (endsection)); 800 fputbytes(out, filetrailer, sizeof (filetrailer)); 801 fclose(out); 802 return (0); 803 } 804