contrib/less/decode.c

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