bin/less/lesskey.c

   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 }