Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/less/lesskey/../lesskey.c	Lines:	0	259	0.0 %
Date:	2017-11-07	Branches:	0	176	0.0 %


/*
 * Copyright (C) 1984-2012  Mark Nudelman
 * Modified for use with illumos by Garrett D'Amore.
 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
 *
 * You may distribute under the terms of either the GNU General Public
 * License or the Less License, as specified in the README file.
 *
 * For more information, see the README file.
 */

/*
 *	lesskey [-o output] [input]
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *	Make a .less file.
 *	If no input file is specified, standard input is used.
 *	If no output file is specified, $HOME/.less is used.
 *
 *	The .less file is used to specify (to "less") user-defined
 *	key bindings.  Basically any sequence of 1 to MAX_CMDLEN
 *	keystrokes may be bound to an existing less function.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *	The input file is an ascii file consisting of a
 *	sequence of lines of the form:
 *		string <whitespace> action [chars] <newline>
 *
 *	"string" is a sequence of command characters which form
 *		the new user-defined command.  The command
 *		characters may be:
 *		1. The actual character itself.
 *		2. A character preceded by ^ to specify a
 *		   control character (e.g. ^X means control-X).
 *		3. A backslash followed by one to three octal digits
 *		   to specify a character by its octal value.
 *		4. A backslash followed by b, e, n, r or t
 *		   to specify \b, ESC, \n, \r or \t, respectively.
 *		5. Any character (other than those mentioned above) preceded
 *		   by a \ to specify the character itself (characters which
 *		   must be preceded by \ include ^, \, and whitespace.
 *	"action" is the name of a "less" action, from the table below.
 *	"chars" is an optional sequence of characters which is treated
 *		as keyboard input after the command is executed.
 *
 *	Blank lines and lines which start with # are ignored,
 *	except for the special control lines:
 *		#command	Signals the beginning of the command
 *				keys section.
 *		#line-edit	Signals the beginning of the line-editing
 *				keys section.
 *		#env		Signals the beginning of the environment
 *				variable section.
 *		#stop		Stops command parsing in less;
 *				causes all default keys to be disabled.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *	The output file is a non-ascii file, consisting of a header,
 *	one or more sections, and a trailer.
 *	Each section begins with a section header, a section length word
 *	and the section data.  Normally there are three sections:
 *		CMD_SECTION	Definition of command keys.
 *		EDIT_SECTION	Definition of editing keys.
 *		END_SECTION	A special section header, with no
 *				length word or section data.
 *
 *	Section data consists of zero or more byte sequences of the form:
 *		string <0> <action>
 *	or
 *		string <0> <action|A_EXTRA> chars <0>
 *
 *	"string" is the command string.
 *	"<0>" is one null byte.
 *	"<action>" is one byte containing the action code (the A_xxx value).
 *	If action is ORed with A_EXTRA, the action byte is followed
 *		by the null-terminated "chars" string.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 */

#include <err.h>

#include "cmd.h"
#include "less.h"
#include "lesskey.h"

struct cmdname {
	char *cn_name;
	int cn_action;
};

static void	lkerr(char *);

struct cmdname cmdnames[] = {
	{ "back-bracket",		A_B_BRACKET },
	{ "back-line",			A_B_LINE },
	{ "back-line-force",		A_BF_LINE },
	{ "back-screen",		A_B_SCREEN },
	{ "back-scroll",		A_B_SCROLL },
	{ "back-search",		A_B_SEARCH },
	{ "back-window",		A_B_WINDOW },
	{ "debug",			A_DEBUG },
	{ "digit",			A_DIGIT },
	{ "display-flag",		A_DISP_OPTION },
	{ "display-option",		A_DISP_OPTION },
	{ "end",			A_GOEND },
	{ "examine",			A_EXAMINE },
	{ "filter",			A_FILTER },
	{ "first-cmd",			A_FIRSTCMD },
	{ "firstcmd",			A_FIRSTCMD },
	{ "flush-repaint",		A_FREPAINT },
	{ "forw-bracket",		A_F_BRACKET },
	{ "forw-forever",		A_F_FOREVER },
	{ "forw-until-hilite",		A_F_UNTIL_HILITE },
	{ "forw-line",			A_F_LINE },
	{ "forw-line-force",		A_FF_LINE },
	{ "forw-screen",		A_F_SCREEN },
	{ "forw-screen-force",		A_FF_SCREEN },
	{ "forw-scroll",		A_F_SCROLL },
	{ "forw-search",		A_F_SEARCH },
	{ "forw-skip",			A_F_SKIP },
	{ "forw-window",		A_F_WINDOW },
	{ "goto-end",			A_GOEND },
	{ "goto-line",			A_GOLINE },
	{ "goto-mark",			A_GOMARK },
	{ "help",			A_HELP },
	{ "index-file",			A_INDEX_FILE },
	{ "invalid",			A_UINVALID },
	{ "left-scroll",		A_LSHIFT },
	{ "next-file",			A_NEXT_FILE },
	{ "next-tag",			A_NEXT_TAG },
	{ "noaction",			A_NOACTION },
	{ "percent",			A_PERCENT },
	{ "pipe",			A_PIPE },
	{ "prev-file",			A_PREV_FILE },
	{ "prev-tag",			A_PREV_TAG },
	{ "quit",			A_QUIT },
	{ "remove-file",		A_REMOVE_FILE },
	{ "repaint",			A_REPAINT },
	{ "repaint-flush",		A_FREPAINT },
	{ "repeat-search",		A_AGAIN_SEARCH },
	{ "repeat-search-all",		A_T_AGAIN_SEARCH },
	{ "reverse-search",		A_REVERSE_SEARCH },
	{ "reverse-search-all",		A_T_REVERSE_SEARCH },
	{ "right-scroll",		A_RSHIFT },
	{ "set-mark",			A_SETMARK },
	{ "status",			A_STAT },
	{ "toggle-flag",		A_OPT_TOGGLE },
	{ "toggle-option",		A_OPT_TOGGLE },
	{ "undo-hilite",		A_UNDO_SEARCH },
	{ "version",			A_VERSION },
	{ "visual",			A_VISUAL },
	{ NULL,				0 }
};

struct cmdname editnames[] = {
	{ "back-complete",	EC_B_COMPLETE },
	{ "backspace",		EC_BACKSPACE },
	{ "delete",		EC_DELETE },
	{ "down",		EC_DOWN },
	{ "end",		EC_END },
	{ "expand",		EC_EXPAND },
	{ "forw-complete",	EC_F_COMPLETE },
	{ "home",		EC_HOME },
	{ "insert",		EC_INSERT },
	{ "invalid",		EC_UINVALID },
	{ "kill-line",		EC_LINEKILL },
	{ "abort",		EC_ABORT },
	{ "left",		EC_LEFT },
	{ "literal",		EC_LITERAL },
	{ "right",		EC_RIGHT },
	{ "up",			EC_UP },
	{ "word-backspace",	EC_W_BACKSPACE },
	{ "word-delete",	EC_W_DELETE },
	{ "word-left",		EC_W_LEFT },
	{ "word-right",		EC_W_RIGHT },
	{ NULL, 0 }
};

struct table {
	struct cmdname *names;
	char *pbuffer;
	char buffer[MAX_USERCMD];
};

struct table cmdtable;
struct table edittable;
struct table vartable;
struct table *currtable = &cmdtable;

char fileheader[] = {
	C0_LESSKEY_MAGIC,
	C1_LESSKEY_MAGIC,
	C2_LESSKEY_MAGIC,
	C3_LESSKEY_MAGIC
};
char filetrailer[] = {
	C0_END_LESSKEY_MAGIC,
	C1_END_LESSKEY_MAGIC,
	C2_END_LESSKEY_MAGIC
};
char cmdsection[1] =	{ CMD_SECTION };
char editsection[1] =	{ EDIT_SECTION };
char varsection[1] =	{ VAR_SECTION };
char endsection[1] =	{ END_SECTION };

char *infile = NULL;
char *outfile = NULL;

int linenum;
int errors;

extern char version[];

static void
usage(void)
{
	(void) fprintf(stderr, "usage: lesskey [-o output] [input]\n");
	exit(1);
}

static char *
mkpathname(char *dirname, char *filename)
{
	char *pathname;
	size_t len;

	len = strlen(dirname) + strlen(filename) + 2;
	pathname = calloc(1, len);
	if (pathname == NULL) {
		fprintf(stderr, "mkpathname: out of memory\n");
		exit(1);
	}
	(void) snprintf(pathname, len, "%s/%s", dirname, filename);
	return (pathname);
}

/*
 * Figure out the name of a default file (in the user's HOME directory).
 */
char *
homefile(char *filename)
{
	char *p;
	char *pathname;

	if ((p = getenv("HOME")) != NULL && *p != '\0') {
		pathname = mkpathname(p, filename);
	} else {
		(void) fprintf(stderr, "cannot find $HOME - "
		    "using current directory\n");
		pathname = mkpathname(".", filename);
	}
	return (pathname);
}

/*
 * Parse command line arguments.
 */
static void
parse_args(int argc, char **argv)
{
	char *arg;

	outfile = NULL;
	while (--argc > 0) {
		arg = *++argv;
		if (arg[0] != '-')
			/* Arg does not start with "-"; it's not an option. */
			break;
		if (arg[1] == '\0')
			/* "-" means standard input. */
			break;
		if (arg[1] == '-' && arg[2] == '\0') {
			/* "--" means end of options. */
			argc--;
			argv++;
			break;
		}
		switch (arg[1]) {
		case '-':
			if (strncmp(arg, "--output", 8) == 0) {
				if (arg[8] == '\0')
					outfile = &arg[8];
				else if (arg[8] == '=')
					outfile = &arg[9];
				else
					usage();
				goto opt_o;
			}
			if (strcmp(arg, "--version") == 0) {
				goto opt_V;
			}
			usage();
			break;
		case 'o':
			outfile = &argv[0][2];
		opt_o:
			if (*outfile == '\0') {
				if (--argc <= 0)
					usage();
				outfile = *(++argv);
			}
			break;
		case 'V':
		opt_V:
			(void) printf("lesskey  version %s\n", version);
			exit(0);
		default:
			usage();
		}
	}
	if (argc > 1)
		usage();
	/*
	 * Open the input file, or use DEF_LESSKEYINFILE if none specified.
	 */
	if (argc > 0)
		infile = *argv;
	else
		infile = homefile(DEF_LESSKEYINFILE);
}

/*
 * Initialize data structures.
 */
static void
init_tables(void)
{
	cmdtable.names = cmdnames;
	cmdtable.pbuffer = cmdtable.buffer;

	edittable.names = editnames;
	edittable.pbuffer = edittable.buffer;

	vartable.names = NULL;
	vartable.pbuffer = vartable.buffer;
}

/*
 * Parse one character of a string.
 */
static char *
tstr(char **pp, int xlate)
{
	char *p;
	char ch;
	int i;
	static char buf[10];
	static char tstr_control_k[] =
		{ SK_SPECIAL_KEY, SK_CONTROL_K, 6, 1, 1, 1, '\0' };

	p = *pp;
	switch (*p) {
	case '\\':
		++p;
		switch (*p) {
		case '0': case '1': case '2': case '3':
		case '4': case '5': case '6': case '7':
			/*
			 * Parse an octal number.
			 */
			ch = 0;
			i = 0;
			do
				ch = 8*ch + (*p - '0');
			while (*++p >= '0' && *p <= '7' && ++i < 3)
				;
			*pp = p;
			if (xlate && ch == CONTROL('K'))
				return (tstr_control_k);
			buf[0] = ch;
			buf[1] = '\0';
			return (buf);
		case 'b':
			*pp = p+1;
			return ("\b");
		case 'e':
			*pp = p+1;
			buf[0] = ESC;
			buf[1] = '\0';
			return (buf);
		case 'n':
			*pp = p+1;
			return ("\n");
		case 'r':
			*pp = p+1;
			return ("\r");
		case 't':
			*pp = p+1;
			return ("\t");
		case 'k':
			if (xlate) {
				switch (*++p) {
				case 'u': ch = SK_UP_ARROW; break;
				case 'd': ch = SK_DOWN_ARROW; break;
				case 'r': ch = SK_RIGHT_ARROW; break;
				case 'l': ch = SK_LEFT_ARROW; break;
				case 'U': ch = SK_PAGE_UP; break;
				case 'D': ch = SK_PAGE_DOWN; break;
				case 'h': ch = SK_HOME; break;
				case 'e': ch = SK_END; break;
				case 'x': ch = SK_DELETE; break;
				default:
					lkerr("illegal char after \\k");
					*pp = p+1;
					return ("");
				}
				*pp = p+1;
				buf[0] = SK_SPECIAL_KEY;
				buf[1] = ch;
				buf[2] = 6;
				buf[3] = 1;
				buf[4] = 1;
				buf[5] = 1;
				buf[6] = '\0';
				return (buf);
			}
			/* FALLTHRU */
		default:
			/*
			 * Backslash followed by any other char
			 * just means that char.
			 */
			*pp = p+1;
			buf[0] = *p;
			buf[1] = '\0';
			if (xlate && buf[0] == CONTROL('K'))
				return (tstr_control_k);
			return (buf);
		}
	case '^':
		/*
		 * Caret means CONTROL.
		 */
		*pp = p+2;
		buf[0] = CONTROL(p[1]);
		buf[1] = '\0';
		if (buf[0] == CONTROL('K'))
			return (tstr_control_k);
		return (buf);
	}
	*pp = p+1;
	buf[0] = *p;
	buf[1] = '\0';
	if (xlate && buf[0] == CONTROL('K'))
		return (tstr_control_k);
	return (buf);
}

/*
 * Skip leading spaces in a string.
 */
char *
skipsp(char *s)
{
	while (*s == ' ' || *s == '\t')
		s++;
	return (s);
}

/*
 * Skip non-space characters in a string.
 */
static char *
skipnsp(char *s)
{
	while (*s != '\0' && *s != ' ' && *s != '\t')
		s++;
	return (s);
}

/*
 * Clean up an input line:
 * strip off the trailing newline & any trailing # comment.
 */
static char *
clean_line(char *s)
{
	int i;

	s = skipsp(s);
	for (i = 0; s[i] != '\n' && s[i] != '\r' && s[i] != '\0'; i++)
		if (s[i] == '#' && (i == 0 || s[i-1] != '\\'))
			break;
	s[i] = '\0';
	return (s);
}

/*
 * Add a byte to the output command table.
 */
static void
add_cmd_char(int c)
{
	if (currtable->pbuffer >= currtable->buffer + MAX_USERCMD) {
		lkerr("too many commands");
		exit(1);
	}
	*(currtable->pbuffer)++ = (char)c;
}

/*
 * Add a string to the output command table.
 */
static void
add_cmd_str(char *s)
{
	for (; *s != '\0'; s++)
		add_cmd_char(*s);
}

/*
 * See if we have a special "control" line.
 */
static int
control_line(char *s)
{
#define	PREFIX(str, pat)	(strncmp(str, pat, strlen(pat)) == 0)

	if (PREFIX(s, "#line-edit")) {
		currtable = &edittable;
		return (1);
	}
	if (PREFIX(s, "#command")) {
		currtable = &cmdtable;
		return (1);
	}
	if (PREFIX(s, "#env")) {
		currtable = &vartable;
		return (1);
	}
	if (PREFIX(s, "#stop")) {
		add_cmd_char('\0');
		add_cmd_char(A_END_LIST);
		return (1);
	}
	return (0);
}

/*
 * Output some bytes.
 */
static void
fputbytes(FILE *fd, char *buf, int len)
{
	while (len-- > 0) {
		(void) fwrite(buf, sizeof (char), 1, fd);
		buf++;
	}
}

/*
 * Output an integer, in special KRADIX form.
 */
static void
fputint(FILE *fd, unsigned int val)
{
	char c;

	if (val >= KRADIX*KRADIX) {
		(void) fprintf(stderr, "error: integer too big (%d > %d)\n",
		    val, KRADIX*KRADIX);
		exit(1);
	}
	c = val % KRADIX;
	(void) fwrite(&c, sizeof (char), 1, fd);
	c = val / KRADIX;
	(void) fwrite(&c, sizeof (char), 1, fd);
}

/*
 * Find an action, given the name of the action.
 */
static int
findaction(char *actname)
{
	int i;

	for (i = 0; currtable->names[i].cn_name != NULL; i++)
		if (strcmp(currtable->names[i].cn_name, actname) == 0)
			return (currtable->names[i].cn_action);
	lkerr("unknown action");
	return (A_INVALID);
}

static void
lkerr(char *s)
{
	(void) fprintf(stderr, "line %d: %s\n", linenum, s);
	errors++;
}


static void
parse_cmdline(char *p)
{
	int cmdlen;
	char *actname;
	int action;
	char *s;
	char c;

	/*
	 * Parse the command string and store it in the current table.
	 */
	cmdlen = 0;
	do {
		s = tstr(&p, 1);
		cmdlen += strlen(s);
		if (cmdlen > MAX_CMDLEN)
			lkerr("command too long");
		else
			add_cmd_str(s);
	} while (*p != ' ' && *p != '\t' && *p != '\0');
	/*
	 * Terminate the command string with a null byte.
	 */
	add_cmd_char('\0');

	/*
	 * Skip white space between the command string
	 * and the action name.
	 * Terminate the action name with a null byte.
	 */
	p = skipsp(p);
	if (*p == '\0') {
		lkerr("missing action");
		return;
	}
	actname = p;
	p = skipnsp(p);
	c = *p;
	*p = '\0';

	/*
	 * Parse the action name and store it in the current table.
	 */
	action = findaction(actname);

	/*
	 * See if an extra string follows the action name.
	 */
	*p = c;
	p = skipsp(p);
	if (*p == '\0') {
		add_cmd_char(action);
	} else {
		/*
		 * OR the special value A_EXTRA into the action byte.
		 * Put the extra string after the action byte.
		 */
		add_cmd_char(action | A_EXTRA);
		while (*p != '\0')
			add_cmd_str(tstr(&p, 0));
		add_cmd_char('\0');
	}
}

static void
parse_varline(char *p)
{
	char *s;

	do {
		s = tstr(&p, 0);
		add_cmd_str(s);
	} while (*p != ' ' && *p != '\t' && *p != '=' && *p != '\0');
	/*
	 * Terminate the variable name with a null byte.
	 */
	add_cmd_char('\0');

	p = skipsp(p);
	if (*p++ != '=') {
		lkerr("missing =");
		return;
	}

	add_cmd_char(EV_OK|A_EXTRA);

	p = skipsp(p);
	while (*p != '\0') {
		s = tstr(&p, 0);
		add_cmd_str(s);
	}
	add_cmd_char('\0');
}

/*
 * Parse a line from the lesskey file.
 */
static void
parse_line(char *line)
{
	char *p;

	/*
	 * See if it is a control line.
	 */
	if (control_line(line))
		return;
	/*
	 * Skip leading white space.
	 * Replace the final newline with a null byte.
	 * Ignore blank lines and comments.
	 */
	p = clean_line(line);
	if (*p == '\0')
		return;

	if (currtable == &vartable)
		parse_varline(p);
	else
		parse_cmdline(p);
}

int
main(int argc, char **argv)
{
	FILE *desc;
	FILE *out;
	char line[1024];

	if (pledge("stdio rpath wpath cpath flock", NULL) == -1)
		err(1, "pledge");

	/*
	 * Process command line arguments.
	 */
	parse_args(argc, argv);
	init_tables();

	/*
	 * Open the input file.
	 */
	if (strcmp(infile, "-") == 0)
		desc = stdin;
	else if ((desc = fopen(infile, "r")) == NULL) {
		perror(infile);
		usage();
	}

	/*
	 * Read and parse the input file, one line at a time.
	 */
	errors = 0;
	linenum = 0;
	while (fgets(line, sizeof (line), desc) != NULL) {
		++linenum;
		parse_line(line);
	}
	fclose(desc);

	/*
	 * Write the output file.
	 * If no output file was specified, use "$HOME/.less"
	 */
	if (errors > 0) {
		(void) fprintf(stderr, "%d errors; no output produced\n",
		    errors);
		exit(1);
	}

	if (outfile == NULL)
		outfile = getenv("LESSKEY");
	if (outfile == NULL)
		outfile = homefile(LESSKEYFILE);
	if ((out = fopen(outfile, "wb")) == NULL) {
		perror(outfile);
		exit(1);
	}

	/* File header */
	fputbytes(out, fileheader, sizeof (fileheader));

	/* Command key section */
	fputbytes(out, cmdsection, sizeof (cmdsection));
	fputint(out, cmdtable.pbuffer - cmdtable.buffer);
	fputbytes(out, (char *)cmdtable.buffer,
	    cmdtable.pbuffer-cmdtable.buffer);

	/* Edit key section */
	fputbytes(out, editsection, sizeof (editsection));
	fputint(out, edittable.pbuffer - edittable.buffer);
	fputbytes(out, (char *)edittable.buffer,
	    edittable.pbuffer-edittable.buffer);

	/* Environment variable section */
	fputbytes(out, varsection, sizeof (varsection));
	fputint(out, vartable.pbuffer - vartable.buffer);
	fputbytes(out, (char *)vartable.buffer,
	    vartable.pbuffer-vartable.buffer);

	/* File trailer */
	fputbytes(out, endsection, sizeof (endsection));
	fputbytes(out, filetrailer, sizeof (filetrailer));
	fclose(out);
	return (0);
}


Generated by: GCOVR (Version 3.3)

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