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