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