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