xref: /freebsd/contrib/less/lesskey_parse.c (revision efe014e6b177ba1b0d70f7df751f5066d4eafe9b) 
1 /*
2  * Copyright (C) 1984-2021  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 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 #include "lesskey.h"
14 #include "cmd.h"
15 #include "xbuf.h"
16 #include "defines.h"
17 
18 #define CONTROL(c)      ((c)&037)
19 #define ESC             CONTROL('[')
20 
21 extern void lesskey_parse_error(char *msg);
22 extern char *homefile(char *filename);
23 extern void *ecalloc(int count, unsigned int size);
24 
25 static int linenum;
26 static int errors;
27 static char *lesskey_file;
28 
29 static struct lesskey_cmdname cmdnames[] =
30 {
31 	{ "back-bracket",         A_B_BRACKET },
32 	{ "back-line",            A_B_LINE },
33 	{ "back-line-force",      A_BF_LINE },
34 	{ "back-screen",          A_B_SCREEN },
35 	{ "back-scroll",          A_B_SCROLL },
36 	{ "back-search",          A_B_SEARCH },
37 	{ "back-window",          A_B_WINDOW },
38 	{ "clear-mark",           A_CLRMARK },
39 	{ "debug",                A_DEBUG },
40 	{ "digit",                A_DIGIT },
41 	{ "display-flag",         A_DISP_OPTION },
42 	{ "display-option",       A_DISP_OPTION },
43 	{ "end",                  A_GOEND },
44 	{ "end-scroll",           A_RRSHIFT },
45 	{ "examine",              A_EXAMINE },
46 	{ "filter",               A_FILTER },
47 	{ "first-cmd",            A_FIRSTCMD },
48 	{ "firstcmd",             A_FIRSTCMD },
49 	{ "flush-repaint",        A_FREPAINT },
50 	{ "forw-bracket",         A_F_BRACKET },
51 	{ "forw-forever",         A_F_FOREVER },
52 	{ "forw-until-hilite",    A_F_UNTIL_HILITE },
53 	{ "forw-line",            A_F_LINE },
54 	{ "forw-line-force",      A_FF_LINE },
55 	{ "forw-screen",          A_F_SCREEN },
56 	{ "forw-screen-force",    A_FF_SCREEN },
57 	{ "forw-scroll",          A_F_SCROLL },
58 	{ "forw-search",          A_F_SEARCH },
59 	{ "forw-window",          A_F_WINDOW },
60 	{ "goto-end",             A_GOEND },
61 	{ "goto-end-buffered",    A_GOEND_BUF },
62 	{ "goto-line",            A_GOLINE },
63 	{ "goto-mark",            A_GOMARK },
64 	{ "help",                 A_HELP },
65 	{ "index-file",           A_INDEX_FILE },
66 	{ "invalid",              A_UINVALID },
67 	{ "left-scroll",          A_LSHIFT },
68 	{ "next-file",            A_NEXT_FILE },
69 	{ "next-tag",             A_NEXT_TAG },
70 	{ "noaction",             A_NOACTION },
71 	{ "no-scroll",            A_LLSHIFT },
72 	{ "percent",              A_PERCENT },
73 	{ "pipe",                 A_PIPE },
74 	{ "prev-file",            A_PREV_FILE },
75 	{ "prev-tag",             A_PREV_TAG },
76 	{ "quit",                 A_QUIT },
77 	{ "remove-file",          A_REMOVE_FILE },
78 	{ "repaint",              A_REPAINT },
79 	{ "repaint-flush",        A_FREPAINT },
80 	{ "repeat-search",        A_AGAIN_SEARCH },
81 	{ "repeat-search-all",    A_T_AGAIN_SEARCH },
82 	{ "reverse-search",       A_REVERSE_SEARCH },
83 	{ "reverse-search-all",   A_T_REVERSE_SEARCH },
84 	{ "right-scroll",         A_RSHIFT },
85 	{ "set-mark",             A_SETMARK },
86 	{ "set-mark-bottom",      A_SETMARKBOT },
87 	{ "shell",                A_SHELL },
88 	{ "status",               A_STAT },
89 	{ "toggle-flag",          A_OPT_TOGGLE },
90 	{ "toggle-option",        A_OPT_TOGGLE },
91 	{ "undo-hilite",          A_UNDO_SEARCH },
92 	{ "clear-search",         A_CLR_SEARCH },
93 	{ "version",              A_VERSION },
94 	{ "visual",               A_VISUAL },
95 	{ NULL,   0 }
96 };
97 
98 static struct lesskey_cmdname editnames[] =
99 {
100 	{ "back-complete",      EC_B_COMPLETE },
101 	{ "backspace",          EC_BACKSPACE },
102 	{ "delete",             EC_DELETE },
103 	{ "down",               EC_DOWN },
104 	{ "end",                EC_END },
105 	{ "expand",             EC_EXPAND },
106 	{ "forw-complete",      EC_F_COMPLETE },
107 	{ "home",               EC_HOME },
108 	{ "insert",             EC_INSERT },
109 	{ "invalid",            EC_UINVALID },
110 	{ "kill-line",          EC_LINEKILL },
111 	{ "abort",              EC_ABORT },
112 	{ "left",               EC_LEFT },
113 	{ "literal",            EC_LITERAL },
114 	{ "right",              EC_RIGHT },
115 	{ "up",                 EC_UP },
116 	{ "word-backspace",     EC_W_BACKSPACE },
117 	{ "word-delete",        EC_W_DELETE },
118 	{ "word-left",          EC_W_LEFT },
119 	{ "word-right",         EC_W_RIGHT },
120 	{ NULL, 0 }
121 };
122 
123 /*
124  * Print a parse error message.
125  */
126 	static void
127 parse_error(s1, s2)
128 	char *s1;
129 	char *s2;
130 {
131 	char buf[1024];
132 	++errors;
133 	snprintf(buf, sizeof(buf), "%s: line %d: %s%s", lesskey_file, linenum, s1, s2);
134 	lesskey_parse_error(buf);
135 }
136 
137 /*
138  * Initialize lesskey_tables.
139  */
140 	static void
141 init_tables(tables)
142 	struct lesskey_tables *tables;
143 {
144 	tables->currtable = &tables->cmdtable;
145 
146 	tables->cmdtable.names = cmdnames;
147 	tables->cmdtable.is_var = 0;
148 	xbuf_init(&tables->cmdtable.buf);
149 
150 	tables->edittable.names = editnames;
151 	tables->edittable.is_var = 0;
152 	xbuf_init(&tables->edittable.buf);
153 
154 	tables->vartable.names = NULL;
155 	tables->vartable.is_var = 1;
156 	xbuf_init(&tables->vartable.buf);
157 }
158 
159 /*
160  * Parse one character of a string.
161  */
162 	static char *
163 tstr(pp, xlate)
164 	char **pp;
165 	int xlate;
166 {
167 	char *p;
168 	char ch;
169 	int i;
170 	static char buf[10];
171 	static char tstr_control_k[] =
172 		{ SK_SPECIAL_KEY, SK_CONTROL_K, 6, 1, 1, 1, '\0' };
173 
174 	p = *pp;
175 	switch (*p)
176 	{
177 	case '\\':
178 		++p;
179 		switch (*p)
180 		{
181 		case '0': case '1': case '2': case '3':
182 		case '4': case '5': case '6': case '7':
183 			/*
184 			 * Parse an octal number.
185 			 */
186 			ch = 0;
187 			i = 0;
188 			do
189 				ch = 8*ch + (*p - '0');
190 			while (*++p >= '0' && *p <= '7' && ++i < 3);
191 			*pp = p;
192 			if (xlate && ch == CONTROL('K'))
193 				return tstr_control_k;
194 			buf[0] = ch;
195 			buf[1] = '\0';
196 			return (buf);
197 		case 'b':
198 			*pp = p+1;
199 			return ("\b");
200 		case 'e':
201 			*pp = p+1;
202 			buf[0] = ESC;
203 			buf[1] = '\0';
204 			return (buf);
205 		case 'n':
206 			*pp = p+1;
207 			return ("\n");
208 		case 'r':
209 			*pp = p+1;
210 			return ("\r");
211 		case 't':
212 			*pp = p+1;
213 			return ("\t");
214 		case 'k':
215 			if (xlate)
216 			{
217 				switch (*++p)
218 				{
219 				case 'u': ch = SK_UP_ARROW; break;
220 				case 'd': ch = SK_DOWN_ARROW; break;
221 				case 'r': ch = SK_RIGHT_ARROW; break;
222 				case 'l': ch = SK_LEFT_ARROW; break;
223 				case 'U': ch = SK_PAGE_UP; break;
224 				case 'D': ch = SK_PAGE_DOWN; break;
225 				case 'h': ch = SK_HOME; break;
226 				case 'e': ch = SK_END; break;
227 				case 'x': ch = SK_DELETE; break;
228 				default: { char buf[2]; buf[0] = *p; buf[1] = '\0';
229 					parse_error("illegal escape sequence \\k", buf);
230 					*pp = p+1;
231 					return (""); }
232 				}
233 				*pp = p+1;
234 				buf[0] = SK_SPECIAL_KEY;
235 				buf[1] = ch;
236 				buf[2] = 6;
237 				buf[3] = 1;
238 				buf[4] = 1;
239 				buf[5] = 1;
240 				buf[6] = '\0';
241 				return (buf);
242 			}
243 			/* FALLTHRU */
244 		default:
245 			/*
246 			 * Backslash followed by any other char
247 			 * just means that char.
248 			 */
249 			*pp = p+1;
250 			buf[0] = *p;
251 			buf[1] = '\0';
252 			if (xlate && buf[0] == CONTROL('K'))
253 				return tstr_control_k;
254 			return (buf);
255 		}
256 	case '^':
257 		/*
258 		 * Caret means CONTROL.
259 		 */
260 		*pp = p+2;
261 		buf[0] = CONTROL(p[1]);
262 		buf[1] = '\0';
263 		if (xlate && buf[0] == CONTROL('K'))
264 			return tstr_control_k;
265 		return (buf);
266 	}
267 	*pp = p+1;
268 	buf[0] = *p;
269 	buf[1] = '\0';
270 	if (xlate && buf[0] == CONTROL('K'))
271 		return tstr_control_k;
272 	return (buf);
273 }
274 
275 	static int
276 issp(ch)
277 	char ch;
278 {
279 	return (ch == ' ' || ch == '\t');
280 }
281 
282 /*
283  * Skip leading spaces in a string.
284  */
285 	static char *
286 skipsp(s)
287 	char *s;
288 {
289 	while (issp(*s))
290 		s++;
291 	return (s);
292 }
293 
294 /*
295  * Skip non-space characters in a string.
296  */
297 	static char *
298 skipnsp(s)
299 	char *s;
300 {
301 	while (*s != '\0' && !issp(*s))
302 		s++;
303 	return (s);
304 }
305 
306 /*
307  * Clean up an input line:
308  * strip off the trailing newline & any trailing # comment.
309  */
310 	static char *
311 clean_line(s)
312 	char *s;
313 {
314 	int i;
315 
316 	s = skipsp(s);
317 	for (i = 0;  s[i] != '\0' && s[i] != '\n' && s[i] != '\r';  i++)
318 		if (s[i] == '#' && (i == 0 || s[i-1] != '\\'))
319 			break;
320 	s[i] = '\0';
321 	return (s);
322 }
323 
324 /*
325  * Add a byte to the output command table.
326  */
327 	static void
328 add_cmd_char(c, tables)
329 	int c;
330 	struct lesskey_tables *tables;
331 {
332 	xbuf_add(&tables->currtable->buf, c);
333 }
334 
335 /*
336  * Add a string to the output command table.
337  */
338 	static void
339 add_cmd_str(s, tables)
340 	char *s;
341 	struct lesskey_tables *tables;
342 {
343 	for ( ;  *s != '\0';  s++)
344 		add_cmd_char(*s, tables);
345 }
346 
347 /*
348  * See if we have a special "control" line.
349  */
350 	static int
351 control_line(s, tables)
352 	char *s;
353 	struct lesskey_tables *tables;
354 {
355 #define PREFIX(str,pat) (strncmp(str,pat,strlen(pat)) == 0)
356 
357 	if (PREFIX(s, "#line-edit"))
358 	{
359 		tables->currtable = &tables->edittable;
360 		return (1);
361 	}
362 	if (PREFIX(s, "#command"))
363 	{
364 		tables->currtable = &tables->cmdtable;
365 		return (1);
366 	}
367 	if (PREFIX(s, "#env"))
368 	{
369 		tables->currtable = &tables->vartable;
370 		return (1);
371 	}
372 	if (PREFIX(s, "#stop"))
373 	{
374 		add_cmd_char('\0', tables);
375 		add_cmd_char(A_END_LIST, tables);
376 		return (1);
377 	}
378 	return (0);
379 }
380 
381 /*
382  * Find an action, given the name of the action.
383  */
384 	static int
385 findaction(actname, tables)
386 	char *actname;
387 	struct lesskey_tables *tables;
388 {
389 	int i;
390 
391 	for (i = 0;  tables->currtable->names[i].cn_name != NULL;  i++)
392 		if (strcmp(tables->currtable->names[i].cn_name, actname) == 0)
393 			return (tables->currtable->names[i].cn_action);
394 	parse_error("unknown action: ", actname);
395 	return (A_INVALID);
396 }
397 
398 /*
399  * Parse a line describing one key binding, of the form
400  *  KEY ACTION [EXTRA]
401  * where KEY is the user key sequence, ACTION is the
402  * resulting less action, and EXTRA is an "extra" user
403  * key sequence injected after the action.
404  */
405 	static void
406 parse_cmdline(p, tables)
407 	char *p;
408 	struct lesskey_tables *tables;
409 {
410 	char *actname;
411 	int action;
412 	char *s;
413 	char c;
414 
415 	/*
416 	 * Parse the command string and store it in the current table.
417 	 */
418 	do
419 	{
420 		s = tstr(&p, 1);
421 		add_cmd_str(s, tables);
422 	} while (*p != '\0' && !issp(*p));
423 	/*
424 	 * Terminate the command string with a null byte.
425 	 */
426 	add_cmd_char('\0', tables);
427 
428 	/*
429 	 * Skip white space between the command string
430 	 * and the action name.
431 	 * Terminate the action name with a null byte.
432 	 */
433 	p = skipsp(p);
434 	if (*p == '\0')
435 	{
436 		parse_error("missing action", "");
437 		return;
438 	}
439 	actname = p;
440 	p = skipnsp(p);
441 	c = *p;
442 	*p = '\0';
443 
444 	/*
445 	 * Parse the action name and store it in the current table.
446 	 */
447 	action = findaction(actname, tables);
448 
449 	/*
450 	 * See if an extra string follows the action name.
451 	 */
452 	*p = c;
453 	p = skipsp(p);
454 	if (*p == '\0')
455 	{
456 		add_cmd_char(action, tables);
457 	} else
458 	{
459 		/*
460 		 * OR the special value A_EXTRA into the action byte.
461 		 * Put the extra string after the action byte.
462 		 */
463 		add_cmd_char(action | A_EXTRA, tables);
464 		while (*p != '\0')
465 			add_cmd_str(tstr(&p, 0), tables);
466 		add_cmd_char('\0', tables);
467 	}
468 }
469 
470 /*
471  * Parse a variable definition line, of the form
472  *  NAME = VALUE
473  */
474 	static void
475 parse_varline(line, tables)
476 	char *line;
477 	struct lesskey_tables *tables;
478 {
479 	char *s;
480 	char *p = line;
481 
482 	do
483 	{
484 		s = tstr(&p, 0);
485 		add_cmd_str(s, tables);
486 	} while (*p != '\0' && !issp(*p) && *p != '=');
487 	/*
488 	 * Terminate the variable name with a null byte.
489 	 */
490 	add_cmd_char('\0', tables);
491 
492 	p = skipsp(p);
493 	if (*p++ != '=')
494 	{
495 		parse_error("missing = in: ", line);
496 		return;
497 	}
498 
499 	add_cmd_char(EV_OK|A_EXTRA, tables);
500 
501 	p = skipsp(p);
502 	while (*p != '\0')
503 	{
504 		s = tstr(&p, 0);
505 		add_cmd_str(s, tables);
506 	}
507 	add_cmd_char('\0', tables);
508 }
509 
510 /*
511  * Parse a line from the lesskey file.
512  */
513 	static void
514 parse_line(line, tables)
515 	char *line;
516 	struct lesskey_tables *tables;
517 {
518 	char *p;
519 
520 	/*
521 	 * See if it is a control line.
522 	 */
523 	if (control_line(line, tables))
524 		return;
525 	/*
526 	 * Skip leading white space.
527 	 * Replace the final newline with a null byte.
528 	 * Ignore blank lines and comments.
529 	 */
530 	p = clean_line(line);
531 	if (*p == '\0')
532 		return;
533 
534 	if (tables->currtable->is_var)
535 		parse_varline(p, tables);
536 	else
537 		parse_cmdline(p, tables);
538 }
539 
540 /*
541  * Parse a lesskey source file and store result in tables.
542  */
543 	int
544 parse_lesskey(infile, tables)
545 	char *infile;
546 	struct lesskey_tables *tables;
547 {
548 	FILE *desc;
549 	char line[1024];
550 
551 	if (infile == NULL)
552 		infile = homefile(DEF_LESSKEYINFILE);
553 	lesskey_file = infile;
554 
555 	init_tables(tables);
556 	errors = 0;
557 	linenum = 0;
558 
559 	/*
560 	 * Open the input file.
561 	 */
562 	if (strcmp(infile, "-") == 0)
563 		desc = stdin;
564 	else if ((desc = fopen(infile, "r")) == NULL)
565 	{
566 		/* parse_error("cannot open lesskey file ", infile); */
567 		return (-1);
568 	}
569 
570 	/*
571 	 * Read and parse the input file, one line at a time.
572 	 */
573 	while (fgets(line, sizeof(line), desc) != NULL)
574 	{
575 		++linenum;
576 		parse_line(line, tables);
577 	}
578 
579 	return (errors);
580 }
581