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