Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/tmux/cmd-list-keys.c	Lines:	0	89	0.0 %
Date:	2016-12-06	Branches:	0	68	0.0 %


/* $OpenBSD: cmd-list-keys.c,v 1.35 2016/06/15 08:54:11 nicm Exp $ */

/*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <stdlib.h>
#include <string.h>

#include "tmux.h"

/*
 * List key bindings.
 */

static enum cmd_retval	 cmd_list_keys_exec(struct cmd *, struct cmd_q *);

static enum cmd_retval	 cmd_list_keys_table(struct cmd *, struct cmd_q *);
static enum cmd_retval	 cmd_list_keys_commands(struct cmd *, struct cmd_q *);

const struct cmd_entry cmd_list_keys_entry = {
	.name = "list-keys",
	.alias = "lsk",

	.args = { "t:T:", 0, 0 },
	.usage = "[-t mode-table] [-T key-table]",

	.flags = CMD_STARTSERVER,
	.exec = cmd_list_keys_exec
};

const struct cmd_entry cmd_list_commands_entry = {
	.name = "list-commands",
	.alias = "lscm",

	.args = { "F:", 0, 0 },
	.usage = "[-F format]",

	.flags = CMD_STARTSERVER,
	.exec = cmd_list_keys_exec
};

static enum cmd_retval
cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
{
	struct args		*args = self->args;
	struct key_table	*table;
	struct key_binding	*bd;
	const char		*key, *tablename, *r;
	char			*cp, tmp[BUFSIZ];
	int			 repeat, width, tablewidth, keywidth;

	if (self->entry == &cmd_list_commands_entry)
		return (cmd_list_keys_commands(self, cmdq));

	if (args_has(args, 't'))
		return (cmd_list_keys_table(self, cmdq));

	tablename = args_get(args, 'T');
	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
		cmdq_error(cmdq, "table %s doesn't exist", tablename);
		return (CMD_RETURN_ERROR);
	}

	repeat = 0;
	tablewidth = keywidth = 0;
	RB_FOREACH(table, key_tables, &key_tables) {
		if (tablename != NULL && strcmp(table->name, tablename) != 0)
			continue;
		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
			key = key_string_lookup_key(bd->key);

			if (bd->can_repeat)
				repeat = 1;

			width = utf8_cstrwidth(table->name);
			if (width > tablewidth)
				tablewidth = width;
			width = utf8_cstrwidth(key);
			if (width > keywidth)
				keywidth = width;
		}
	}

	RB_FOREACH(table, key_tables, &key_tables) {
		if (tablename != NULL && strcmp(table->name, tablename) != 0)
			continue;
		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
			key = key_string_lookup_key(bd->key);

			if (!repeat)
				r = "";
			else if (bd->can_repeat)
				r = "-r ";
			else
				r = "   ";
			xsnprintf(tmp, sizeof tmp, "%s-T ", r);

			cp = utf8_padcstr(table->name, tablewidth);
			strlcat(tmp, cp, sizeof tmp);
			strlcat(tmp, " ", sizeof tmp);
			free(cp);

			cp = utf8_padcstr(key, keywidth);
			strlcat(tmp, cp, sizeof tmp);
			strlcat(tmp, " ", sizeof tmp);
			free(cp);

			cp = cmd_list_print(bd->cmdlist);
			strlcat(tmp, cp, sizeof tmp);
			free(cp);

			cmdq_print(cmdq, "bind-key %s", tmp);
		}
	}

	return (CMD_RETURN_NORMAL);
}

static enum cmd_retval
cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
{
	struct args			*args = self->args;
	const char			*tablename;
	const struct mode_key_table	*mtab;
	struct mode_key_binding		*mbind;
	const char			*key, *cmdstr, *mode;
	int			 	 width, keywidth, any_mode;

	tablename = args_get(args, 't');
	if ((mtab = mode_key_findtable(tablename)) == NULL) {
		cmdq_error(cmdq, "unknown key table: %s", tablename);
		return (CMD_RETURN_ERROR);
	}

	width = 0;
	any_mode = 0;
	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
		key = key_string_lookup_key(mbind->key);

		if (mbind->mode != 0)
			any_mode = 1;

		keywidth = strlen(key);
		if (keywidth > width)
			width = keywidth;
	}

	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
		key = key_string_lookup_key(mbind->key);

		mode = "";
		if (mbind->mode != 0)
			mode = "c";
		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
		if (cmdstr != NULL) {
			cmdq_print(cmdq, "bind-key -%st %s%s %*s %s%s%s%s",
			    mode, any_mode && *mode == '\0' ? " " : "",
			    mtab->name, (int) width, key, cmdstr,
			    mbind->arg != NULL ? " \"" : "",
			    mbind->arg != NULL ? mbind->arg : "",
			    mbind->arg != NULL ? "\"": "");
		}
	}

	return (CMD_RETURN_NORMAL);
}

static enum cmd_retval
cmd_list_keys_commands(struct cmd *self, struct cmd_q *cmdq)
{
	struct args		*args = self->args;
	const struct cmd_entry	**entryp;
	const struct cmd_entry	 *entry;
	struct format_tree	 *ft;
	const char		 *template;
	char			 *line;

	if ((template = args_get(args, 'F')) == NULL) {
		template = "#{command_list_name}"
		    "#{?command_list_alias, (#{command_list_alias}),} "
		    "#{command_list_usage}";
	}

	ft = format_create(cmdq, 0);
	format_defaults(ft, NULL, NULL, NULL, NULL);

	for (entryp = cmd_table; *entryp != NULL; entryp++) {
		entry = *entryp;

		format_add(ft, "command_list_name", "%s", entry->name);
		if (entry->alias != NULL) {
			format_add(ft, "command_list_alias", "%s",
			    entry->alias);
		}
		if (entry->alias != NULL) {
			format_add(ft, "command_list_usage", "%s",
			    entry->usage);
		}

		line = format_expand(ft, template);
		if (*line != '\0')
			cmdq_print(cmdq, "%s", line);
		free(line);
	}

	format_free(ft);
	return (CMD_RETURN_NORMAL);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cmd-list-keys.c,v 1.35 2016/06/15 08:54:11 nicm Exp $ */
2
3			/*
4			* Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15			* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16			* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20
21			#include <stdlib.h>
22			#include <string.h>
23
24			#include "tmux.h"
25
26			/*
27			* List key bindings.
28			*/
29
30			static enum cmd_retval cmd_list_keys_exec(struct cmd , struct cmd_q );
31
32			static enum cmd_retval cmd_list_keys_table(struct cmd , struct cmd_q );
33			static enum cmd_retval cmd_list_keys_commands(struct cmd , struct cmd_q );
34
35			const struct cmd_entry cmd_list_keys_entry = {
36			.name = "list-keys",
37			.alias = "lsk",
38
39			.args = { "t:T:", 0, 0 },
40			.usage = "[-t mode-table] [-T key-table]",
41
42			.flags = CMD_STARTSERVER,
43			.exec = cmd_list_keys_exec
44			};
45
46			const struct cmd_entry cmd_list_commands_entry = {
47			.name = "list-commands",
48			.alias = "lscm",
49
50			.args = { "F:", 0, 0 },
51			.usage = "[-F format]",
52
53			.flags = CMD_STARTSERVER,
54			.exec = cmd_list_keys_exec
55			};
56
57			static enum cmd_retval
58			cmd_list_keys_exec(struct cmd self, struct cmd_q cmdq)
59			{
60			struct args *args = self->args;
61			struct key_table *table;
62			struct key_binding *bd;
63			const char key, tablename, *r;
64			char *cp, tmp[BUFSIZ];
65			int repeat, width, tablewidth, keywidth;
66
67			if (self->entry == &cmd_list_commands_entry)
68			return (cmd_list_keys_commands(self, cmdq));
69
70			if (args_has(args, 't'))
71			return (cmd_list_keys_table(self, cmdq));
72
73			tablename = args_get(args, 'T');
74			if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
75			cmdq_error(cmdq, "table %s doesn't exist", tablename);
76			return (CMD_RETURN_ERROR);
77			}
78
79			repeat = 0;
80			tablewidth = keywidth = 0;
81			RB_FOREACH(table, key_tables, &key_tables) {
82			if (tablename != NULL && strcmp(table->name, tablename) != 0)
83			continue;
84			RB_FOREACH(bd, key_bindings, &table->key_bindings) {
85			key = key_string_lookup_key(bd->key);
86
87			if (bd->can_repeat)
88			repeat = 1;
89
90			width = utf8_cstrwidth(table->name);
91			if (width > tablewidth)
92			tablewidth = width;
93			width = utf8_cstrwidth(key);
94			if (width > keywidth)
95			keywidth = width;
96			}
97			}
98
99			RB_FOREACH(table, key_tables, &key_tables) {
100			if (tablename != NULL && strcmp(table->name, tablename) != 0)
101			continue;
102			RB_FOREACH(bd, key_bindings, &table->key_bindings) {
103			key = key_string_lookup_key(bd->key);
104
105			if (!repeat)
106			r = "";
107			else if (bd->can_repeat)
108			r = "-r ";
109			else
110			r = " ";
111			xsnprintf(tmp, sizeof tmp, "%s-T ", r);
112
113			cp = utf8_padcstr(table->name, tablewidth);
114			strlcat(tmp, cp, sizeof tmp);
115			strlcat(tmp, " ", sizeof tmp);
116			free(cp);
117
118			cp = utf8_padcstr(key, keywidth);
119			strlcat(tmp, cp, sizeof tmp);
120			strlcat(tmp, " ", sizeof tmp);
121			free(cp);
122
123			cp = cmd_list_print(bd->cmdlist);
124			strlcat(tmp, cp, sizeof tmp);
125			free(cp);
126
127			cmdq_print(cmdq, "bind-key %s", tmp);
128			}
129			}
130
131			return (CMD_RETURN_NORMAL);
132			}
133
134			static enum cmd_retval
135			cmd_list_keys_table(struct cmd self, struct cmd_q cmdq)
136			{
137			struct args *args = self->args;
138			const char *tablename;
139			const struct mode_key_table *mtab;
140			struct mode_key_binding *mbind;
141			const char key, cmdstr, *mode;
142			int width, keywidth, any_mode;
143
144			tablename = args_get(args, 't');
145			if ((mtab = mode_key_findtable(tablename)) == NULL) {
146			cmdq_error(cmdq, "unknown key table: %s", tablename);
147			return (CMD_RETURN_ERROR);
148			}
149
150			width = 0;
151			any_mode = 0;
152			RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
153			key = key_string_lookup_key(mbind->key);
154
155			if (mbind->mode != 0)
156			any_mode = 1;
157
158			keywidth = strlen(key);
159			if (keywidth > width)
160			width = keywidth;
161			}
162
163			RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
164			key = key_string_lookup_key(mbind->key);
165
166			mode = "";
167			if (mbind->mode != 0)
168			mode = "c";
169			cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
170			if (cmdstr != NULL) {
171			cmdq_print(cmdq, "bind-key -%st %s%s %*s %s%s%s%s",
172			mode, any_mode && *mode == '\0' ? " " : "",
173			mtab->name, (int) width, key, cmdstr,
174			mbind->arg != NULL ? " \"" : "",
175			mbind->arg != NULL ? mbind->arg : "",
176			mbind->arg != NULL ? "\"": "");
177			}
178			}
179
180			return (CMD_RETURN_NORMAL);
181			}
182
183			static enum cmd_retval
184			cmd_list_keys_commands(struct cmd self, struct cmd_q cmdq)
185			{
186			struct args *args = self->args;
187			const struct cmd_entry **entryp;
188			const struct cmd_entry *entry;
189			struct format_tree *ft;
190			const char *template;
191			char *line;
192
193			if ((template = args_get(args, 'F')) == NULL) {
194			template = "#{command_list_name}"
195			"#{?command_list_alias, (#{command_list_alias}),} "
196			"#{command_list_usage}";
197			}
198
199			ft = format_create(cmdq, 0);
200			format_defaults(ft, NULL, NULL, NULL, NULL);
201
202			for (entryp = cmd_table; *entryp != NULL; entryp++) {
203			entry = *entryp;
204
205			format_add(ft, "command_list_name", "%s", entry->name);
206			if (entry->alias != NULL) {
207			format_add(ft, "command_list_alias", "%s",
208			entry->alias);
209			}
210			if (entry->alias != NULL) {
211			format_add(ft, "command_list_usage", "%s",
212			entry->usage);
213			}
214
215			line = format_expand(ft, template);
216			if (*line != '\0')
217			cmdq_print(cmdq, "%s", line);
218			free(line);
219			}
220
221			format_free(ft);
222			return (CMD_RETURN_NORMAL);
223			}