Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/tmux/cmd-set-option.c	Lines:	0	210	0.0 %
Date:	2016-12-06	Branches:	0	172	0.0 %


/* $OpenBSD: cmd-set-option.c,v 1.96 2016/05/30 09:50:20 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"

/*
 * Set an option.
 */

enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmd_q *);

enum cmd_retval	cmd_set_option_user(struct cmd *, struct cmd_q *,
	    const char *, const char *);

int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
int	cmd_set_option_set(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);

struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);
struct options_entry *cmd_set_option_style(struct cmd *, struct cmd_q *,
	    const struct options_table_entry *, struct options *,
	    const char *);

const struct cmd_entry cmd_set_option_entry = {
	.name = "set-option",
	.alias = "set",

	.args = { "agoqst:uw", 1, 2 },
	.usage = "[-agosquw] [-t target-window] option [value]",

	.tflag = CMD_WINDOW_CANFAIL,

	.flags = 0,
	.exec = cmd_set_option_exec
};

const struct cmd_entry cmd_set_window_option_entry = {
	.name = "set-window-option",
	.alias = "setw",

	.args = { "agoqt:u", 1, 2 },
	.usage = "[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",

	.tflag = CMD_WINDOW_CANFAIL,

	.flags = 0,
	.exec = cmd_set_option_exec
};

enum cmd_retval
cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
{
	struct args				*args = self->args;
	struct session				*s = cmdq->state.tflag.s;
	struct winlink				*wl = cmdq->state.tflag.wl;
	struct window				*w;
	struct client				*c;
	const struct options_table_entry	*oe;
	struct options				*oo;
	const char				*optstr, *valstr, *target;

	/* Get the option name and value. */
	optstr = args->argv[0];
	if (*optstr == '\0') {
		cmdq_error(cmdq, "invalid option");
		return (CMD_RETURN_ERROR);
	}
	if (args->argc < 2)
		valstr = NULL;
	else
		valstr = args->argv[1];

	/* Is this a user option? */
	if (*optstr == '@')
		return (cmd_set_option_user(self, cmdq, optstr, valstr));

	/* Find the option entry, try each table. */
	oe = NULL;
	if (options_table_find(optstr, &oe) != 0) {
		if (!args_has(args, 'q')) {
			cmdq_error(cmdq, "ambiguous option: %s", optstr);
			return (CMD_RETURN_ERROR);
		}
		return (CMD_RETURN_NORMAL);
	}
	if (oe == NULL) {
		if (!args_has(args, 'q')) {
			cmdq_error(cmdq, "unknown option: %s", optstr);
			return (CMD_RETURN_ERROR);
		}
		return (CMD_RETURN_NORMAL);
	}

	/* Work out the tree from the scope of the option. */
	if (oe->scope == OPTIONS_TABLE_SERVER)
		oo = global_options;
	else if (oe->scope == OPTIONS_TABLE_WINDOW) {
		if (args_has(self->args, 'g'))
			oo = global_w_options;
		else if (wl == NULL) {
			target = args_get(args, 't');
			if (target != NULL) {
				cmdq_error(cmdq, "no such window: %s",
				    target);
			} else
				cmdq_error(cmdq, "no current window");
			return (CMD_RETURN_ERROR);
		} else
			oo = wl->window->options;
	} else if (oe->scope == OPTIONS_TABLE_SESSION) {
		if (args_has(self->args, 'g'))
			oo = global_s_options;
		else if (s == NULL) {
			target = args_get(args, 't');
			if (target != NULL) {
				cmdq_error(cmdq, "no such session: %s",
				    target);
			} else
				cmdq_error(cmdq, "no current session");
			return (CMD_RETURN_ERROR);
		} else
			oo = s->options;
	} else {
		cmdq_error(cmdq, "unknown table");
		return (CMD_RETURN_ERROR);
	}

	/* Unset or set the option. */
	if (args_has(args, 'u')) {
		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
			return (CMD_RETURN_ERROR);
	} else {
		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
			if (!args_has(args, 'q')) {
				cmdq_error(cmdq, "already set: %s", optstr);
				return (CMD_RETURN_ERROR);
			}
			return (CMD_RETURN_NORMAL);
		}
		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
			return (CMD_RETURN_ERROR);
	}

	/* Start or stop timers if necessary. */
	if (strcmp(oe->name, "automatic-rename") == 0) {
		RB_FOREACH(w, windows, &windows) {
			if (options_get_number(w->options, "automatic-rename"))
				w->active->flags |= PANE_CHANGED;
		}
	}
	if (strcmp(oe->name, "key-table") == 0) {
		TAILQ_FOREACH(c, &clients, entry)
			server_client_set_key_table(c, NULL);
	}
	if (strcmp(oe->name, "status") == 0 ||
	    strcmp(oe->name, "status-interval") == 0)
		status_timer_start_all();
	if (strcmp(oe->name, "monitor-silence") == 0)
		alerts_reset_all();
	if (strcmp(oe->name, "window-style") == 0 ||
	    strcmp(oe->name, "window-active-style") == 0) {
		RB_FOREACH(w, windows, &windows)
			w->flags |= WINDOW_STYLECHANGED;
	}

	/* When the pane-border-status option has been changed, resize panes. */
	if (strcmp(oe->name, "pane-border-status") == 0) {
		RB_FOREACH(w, windows, &windows)
			layout_fix_panes(w, w->sx, w->sy);
	}

	/* Update sizes and redraw. May not need it but meh. */
	recalculate_sizes();
	TAILQ_FOREACH(c, &clients, entry) {
		if (c->session != NULL)
			server_redraw_client(c);
	}

	return (CMD_RETURN_NORMAL);
}

/* Set user option. */
enum cmd_retval
cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
    const char *valstr)
{
	struct args	*args = self->args;
	struct session	*s = cmdq->state.tflag.s;
	struct winlink	*wl = cmdq->state.tflag.wl;
	struct options	*oo;

	if (args_has(args, 's'))
		oo = global_options;
	else if (args_has(self->args, 'w') ||
	    self->entry == &cmd_set_window_option_entry) {
		if (args_has(self->args, 'g'))
			oo = global_w_options;
		else
			oo = wl->window->options;
	} else {
		if (args_has(self->args, 'g'))
			oo = global_s_options;
		else
			oo = s->options;
	}

	if (args_has(args, 'u')) {
		if (options_find1(oo, optstr) == NULL) {
			if (!args_has(args, 'q')) {
				cmdq_error(cmdq, "unknown option: %s", optstr);
				return (CMD_RETURN_ERROR);
			}
			return (CMD_RETURN_NORMAL);
		}
		if (valstr != NULL) {
			cmdq_error(cmdq, "value passed to unset option: %s",
			    optstr);
			return (CMD_RETURN_ERROR);
		}
		options_remove(oo, optstr);
	} else {
		if (valstr == NULL) {
			cmdq_error(cmdq, "empty value");
			return (CMD_RETURN_ERROR);
		}
		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
			if (!args_has(args, 'q')) {
				cmdq_error(cmdq, "already set: %s", optstr);
				return (CMD_RETURN_ERROR);
			}
			return (CMD_RETURN_NORMAL);
		}
		options_set_string(oo, optstr, "%s", valstr);
	}
	return (CMD_RETURN_NORMAL);
}

/* Unset an option. */
int
cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	struct args	*args = self->args;

	if (value != NULL) {
		cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
		return (-1);
	}

	if (args_has(args, 'g') || oo == global_options) {
		switch (oe->type) {
		case OPTIONS_TABLE_STRING:
			options_set_string(oo, oe->name, "%s", oe->default_str);
			break;
		case OPTIONS_TABLE_STYLE:
			options_set_style(oo, oe->name, oe->default_str, 0);
			break;
		default:
			options_set_number(oo, oe->name, oe->default_num);
			break;
		}
	} else
		options_remove(oo, oe->name);
	return (0);
}

/* Set an option. */
int
cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	struct options_entry	*o;

	switch (oe->type) {
	case OPTIONS_TABLE_FLAG:
	case OPTIONS_TABLE_CHOICE:
		break;
	default:
		if (value == NULL) {
			cmdq_error(cmdq, "empty value");
			return (-1);
		}
	}

	o = NULL;
	switch (oe->type) {
	case OPTIONS_TABLE_STRING:
		o = cmd_set_option_string(self, cmdq, oe, oo, value);
		break;
	case OPTIONS_TABLE_NUMBER:
		o = cmd_set_option_number(self, cmdq, oe, oo, value);
		break;
	case OPTIONS_TABLE_KEY:
		o = cmd_set_option_key(self, cmdq, oe, oo, value);
		break;
	case OPTIONS_TABLE_COLOUR:
		o = cmd_set_option_colour(self, cmdq, oe, oo, value);
		if (o != NULL)
			style_update_new(oo, o->name, oe->style);
		break;
	case OPTIONS_TABLE_ATTRIBUTES:
		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
		if (o != NULL)
			style_update_new(oo, o->name, oe->style);
		break;
	case OPTIONS_TABLE_FLAG:
		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
		break;
	case OPTIONS_TABLE_CHOICE:
		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
		break;
	case OPTIONS_TABLE_STYLE:
		o = cmd_set_option_style(self, cmdq, oe, oo, value);
		break;
	}
	if (o == NULL)
		return (-1);
	return (0);
}

/* Set a string option. */
struct options_entry *
cmd_set_option_string(struct cmd *self, __unused struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	struct args		*args = self->args;
	struct options_entry	*o;
	char			*oldval, *newval;

	if (args_has(args, 'a')) {
		oldval = options_get_string(oo, oe->name);
		xasprintf(&newval, "%s%s", oldval, value);
	} else
		newval = xstrdup(value);

	o = options_set_string(oo, oe->name, "%s", newval);

	free(newval);
	return (o);
}

/* Set a number option. */
struct options_entry *
cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	long long	 ll;
	const char     	*errstr;

	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
	if (errstr != NULL) {
		cmdq_error(cmdq, "value is %s: %s", errstr, value);
		return (NULL);
	}

	return (options_set_number(oo, oe->name, ll));
}

/* Set a key option. */
struct options_entry *
cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	key_code	key;

	key = key_string_lookup_string(value);
	if (key == KEYC_UNKNOWN) {
		cmdq_error(cmdq, "bad key: %s", value);
		return (NULL);
	}

	return (options_set_number(oo, oe->name, key));
}

/* Set a colour option. */
struct options_entry *
cmd_set_option_colour(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	int	colour;

	if ((colour = colour_fromstring(value)) == -1) {
		cmdq_error(cmdq, "bad colour: %s", value);
		return (NULL);
	}

	return (options_set_number(oo, oe->name, colour));
}

/* Set an attributes option. */
struct options_entry *
cmd_set_option_attributes(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	int	attr;

	if ((attr = attributes_fromstring(value)) == -1) {
		cmdq_error(cmdq, "bad attributes: %s", value);
		return (NULL);
	}

	return (options_set_number(oo, oe->name, attr));
}

/* Set a flag option. */
struct options_entry *
cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	int	flag;

	if (value == NULL || *value == '\0')
		flag = !options_get_number(oo, oe->name);
	else {
		if ((value[0] == '1' && value[1] == '\0') ||
		    strcasecmp(value, "on") == 0 ||
		    strcasecmp(value, "yes") == 0)
			flag = 1;
		else if ((value[0] == '0' && value[1] == '\0') ||
		    strcasecmp(value, "off") == 0 ||
		    strcasecmp(value, "no") == 0)
			flag = 0;
		else {
			cmdq_error(cmdq, "bad value: %s", value);
			return (NULL);
		}
	}

	return (options_set_number(oo, oe->name, flag));
}

/* Set a choice option. */
struct options_entry *
cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	const char	**choicep;
	int		  n, choice = -1;

	if (value == NULL) {
		choice = options_get_number(oo, oe->name);
		if (choice < 2)
			choice = !choice;
	} else {
		n = 0;
		for (choicep = oe->choices; *choicep != NULL; choicep++) {
			n++;
			if (strncmp(*choicep, value, strlen(value)) != 0)
				continue;

			if (choice != -1) {
				cmdq_error(cmdq, "ambiguous value: %s", value);
				return (NULL);
			}
			choice = n - 1;
		}
		if (choice == -1) {
			cmdq_error(cmdq, "unknown value: %s", value);
			return (NULL);
		}
	}

	return (options_set_number(oo, oe->name, choice));
}

/* Set a style option. */
struct options_entry *
cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
{
	struct args		*args = self->args;
	struct options_entry	*o;
	int			 append;

	append = args_has(args, 'a');
	if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
		cmdq_error(cmdq, "bad style: %s", value);
		return (NULL);
	}

	style_update_old(oo, oe->name, &o->style);
	return (o);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cmd-set-option.c,v 1.96 2016/05/30 09:50:20 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			* Set an option.
28			*/
29
30			enum cmd_retval cmd_set_option_exec(struct cmd , struct cmd_q );
31
32			enum cmd_retval cmd_set_option_user(struct cmd , struct cmd_q ,
33			const char , const char );
34
35			int cmd_set_option_unset(struct cmd , struct cmd_q ,
36			const struct options_table_entry , struct options ,
37			const char *);
38			int cmd_set_option_set(struct cmd , struct cmd_q ,
39			const struct options_table_entry , struct options ,
40			const char *);
41
42			struct options_entry cmd_set_option_string(struct cmd , struct cmd_q *,
43			const struct options_table_entry , struct options ,
44			const char *);
45			struct options_entry cmd_set_option_number(struct cmd , struct cmd_q *,
46			const struct options_table_entry , struct options ,
47			const char *);
48			struct options_entry cmd_set_option_key(struct cmd , struct cmd_q *,
49			const struct options_table_entry , struct options ,
50			const char *);
51			struct options_entry cmd_set_option_colour(struct cmd , struct cmd_q *,
52			const struct options_table_entry , struct options ,
53			const char *);
54			struct options_entry cmd_set_option_attributes(struct cmd , struct cmd_q *,
55			const struct options_table_entry , struct options ,
56			const char *);
57			struct options_entry cmd_set_option_flag(struct cmd , struct cmd_q *,
58			const struct options_table_entry , struct options ,
59			const char *);
60			struct options_entry cmd_set_option_choice(struct cmd , struct cmd_q *,
61			const struct options_table_entry , struct options ,
62			const char *);
63			struct options_entry cmd_set_option_style(struct cmd , struct cmd_q *,
64			const struct options_table_entry , struct options ,
65			const char *);
66
67			const struct cmd_entry cmd_set_option_entry = {
68			.name = "set-option",
69			.alias = "set",
70
71			.args = { "agoqst:uw", 1, 2 },
72			.usage = "[-agosquw] [-t target-window] option [value]",
73
74			.tflag = CMD_WINDOW_CANFAIL,
75
76			.flags = 0,
77			.exec = cmd_set_option_exec
78			};
79
80			const struct cmd_entry cmd_set_window_option_entry = {
81			.name = "set-window-option",
82			.alias = "setw",
83
84			.args = { "agoqt:u", 1, 2 },
85			.usage = "[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
86
87			.tflag = CMD_WINDOW_CANFAIL,
88
89			.flags = 0,
90			.exec = cmd_set_option_exec
91			};
92
93			enum cmd_retval
94			cmd_set_option_exec(struct cmd self, struct cmd_q cmdq)
95			{
96			struct args *args = self->args;
97			struct session *s = cmdq->state.tflag.s;
98			struct winlink *wl = cmdq->state.tflag.wl;
99			struct window *w;
100			struct client *c;
101			const struct options_table_entry *oe;
102			struct options *oo;
103			const char optstr, valstr, *target;
104
105			/* Get the option name and value. */
106			optstr = args->argv[0];
107			if (*optstr == '\0') {
108			cmdq_error(cmdq, "invalid option");
109			return (CMD_RETURN_ERROR);
110			}
111			if (args->argc < 2)
112			valstr = NULL;
113			else
114			valstr = args->argv[1];
115
116			/* Is this a user option? */
117			if (*optstr == '@')
118			return (cmd_set_option_user(self, cmdq, optstr, valstr));
119
120			/* Find the option entry, try each table. */
121			oe = NULL;
122			if (options_table_find(optstr, &oe) != 0) {
123			if (!args_has(args, 'q')) {
124			cmdq_error(cmdq, "ambiguous option: %s", optstr);
125			return (CMD_RETURN_ERROR);
126			}
127			return (CMD_RETURN_NORMAL);
128			}
129			if (oe == NULL) {
130			if (!args_has(args, 'q')) {
131			cmdq_error(cmdq, "unknown option: %s", optstr);
132			return (CMD_RETURN_ERROR);
133			}
134			return (CMD_RETURN_NORMAL);
135			}
136
137			/* Work out the tree from the scope of the option. */
138			if (oe->scope == OPTIONS_TABLE_SERVER)
139			oo = global_options;
140			else if (oe->scope == OPTIONS_TABLE_WINDOW) {
141			if (args_has(self->args, 'g'))
142			oo = global_w_options;
143			else if (wl == NULL) {
144			target = args_get(args, 't');
145			if (target != NULL) {
146			cmdq_error(cmdq, "no such window: %s",
147			target);
148			} else
149			cmdq_error(cmdq, "no current window");
150			return (CMD_RETURN_ERROR);
151			} else
152			oo = wl->window->options;
153			} else if (oe->scope == OPTIONS_TABLE_SESSION) {
154			if (args_has(self->args, 'g'))
155			oo = global_s_options;
156			else if (s == NULL) {
157			target = args_get(args, 't');
158			if (target != NULL) {
159			cmdq_error(cmdq, "no such session: %s",
160			target);
161			} else
162			cmdq_error(cmdq, "no current session");
163			return (CMD_RETURN_ERROR);
164			} else
165			oo = s->options;
166			} else {
167			cmdq_error(cmdq, "unknown table");
168			return (CMD_RETURN_ERROR);
169			}
170
171			/* Unset or set the option. */
172			if (args_has(args, 'u')) {
173			if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
174			return (CMD_RETURN_ERROR);
175			} else {
176			if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
177			if (!args_has(args, 'q')) {
178			cmdq_error(cmdq, "already set: %s", optstr);
179			return (CMD_RETURN_ERROR);
180			}
181			return (CMD_RETURN_NORMAL);
182			}
183			if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
184			return (CMD_RETURN_ERROR);
185			}
186
187			/* Start or stop timers if necessary. */
188			if (strcmp(oe->name, "automatic-rename") == 0) {
189			RB_FOREACH(w, windows, &windows) {
190			if (options_get_number(w->options, "automatic-rename"))
191			w->active->flags \|= PANE_CHANGED;
192			}
193			}
194			if (strcmp(oe->name, "key-table") == 0) {
195			TAILQ_FOREACH(c, &clients, entry)
196			server_client_set_key_table(c, NULL);
197			}
198			if (strcmp(oe->name, "status") == 0 \|\|
199			strcmp(oe->name, "status-interval") == 0)
200			status_timer_start_all();
201			if (strcmp(oe->name, "monitor-silence") == 0)
202			alerts_reset_all();
203			if (strcmp(oe->name, "window-style") == 0 \|\|
204			strcmp(oe->name, "window-active-style") == 0) {
205			RB_FOREACH(w, windows, &windows)
206			w->flags \|= WINDOW_STYLECHANGED;
207			}
208
209			/* When the pane-border-status option has been changed, resize panes. */
210			if (strcmp(oe->name, "pane-border-status") == 0) {
211			RB_FOREACH(w, windows, &windows)
212			layout_fix_panes(w, w->sx, w->sy);
213			}
214
215			/* Update sizes and redraw. May not need it but meh. */
216			recalculate_sizes();
217			TAILQ_FOREACH(c, &clients, entry) {
218			if (c->session != NULL)
219			server_redraw_client(c);
220			}
221
222			return (CMD_RETURN_NORMAL);
223			}
224
225			/* Set user option. */
226			enum cmd_retval
227			cmd_set_option_user(struct cmd self, struct cmd_q cmdq, const char *optstr,
228			const char *valstr)
229			{
230			struct args *args = self->args;
231			struct session *s = cmdq->state.tflag.s;
232			struct winlink *wl = cmdq->state.tflag.wl;
233			struct options *oo;
234
235			if (args_has(args, 's'))
236			oo = global_options;
237			else if (args_has(self->args, 'w') \|\|
238			self->entry == &cmd_set_window_option_entry) {
239			if (args_has(self->args, 'g'))
240			oo = global_w_options;
241			else
242			oo = wl->window->options;
243			} else {
244			if (args_has(self->args, 'g'))
245			oo = global_s_options;
246			else
247			oo = s->options;
248			}
249
250			if (args_has(args, 'u')) {
251			if (options_find1(oo, optstr) == NULL) {
252			if (!args_has(args, 'q')) {
253			cmdq_error(cmdq, "unknown option: %s", optstr);
254			return (CMD_RETURN_ERROR);
255			}
256			return (CMD_RETURN_NORMAL);
257			}
258			if (valstr != NULL) {
259			cmdq_error(cmdq, "value passed to unset option: %s",
260			optstr);
261			return (CMD_RETURN_ERROR);
262			}
263			options_remove(oo, optstr);
264			} else {
265			if (valstr == NULL) {
266			cmdq_error(cmdq, "empty value");
267			return (CMD_RETURN_ERROR);
268			}
269			if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
270			if (!args_has(args, 'q')) {
271			cmdq_error(cmdq, "already set: %s", optstr);
272			return (CMD_RETURN_ERROR);
273			}
274			return (CMD_RETURN_NORMAL);
275			}
276			options_set_string(oo, optstr, "%s", valstr);
277			}
278			return (CMD_RETURN_NORMAL);
279			}
280
281			/* Unset an option. */
282			int
283			cmd_set_option_unset(struct cmd self, struct cmd_q cmdq,
284			const struct options_table_entry oe, struct options oo,
285			const char *value)
286			{
287			struct args *args = self->args;
288
289			if (value != NULL) {
290			cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
291			return (-1);
292			}
293
294			if (args_has(args, 'g') \|\| oo == global_options) {
295			switch (oe->type) {
296			case OPTIONS_TABLE_STRING:
297			options_set_string(oo, oe->name, "%s", oe->default_str);
298			break;
299			case OPTIONS_TABLE_STYLE:
300			options_set_style(oo, oe->name, oe->default_str, 0);
301			break;
302			default:
303			options_set_number(oo, oe->name, oe->default_num);
304			break;
305			}
306			} else
307			options_remove(oo, oe->name);
308			return (0);
309			}
310
311			/* Set an option. */
312			int
313			cmd_set_option_set(struct cmd self, struct cmd_q cmdq,
314			const struct options_table_entry oe, struct options oo,
315			const char *value)
316			{
317			struct options_entry *o;
318
319			switch (oe->type) {
320			case OPTIONS_TABLE_FLAG:
321			case OPTIONS_TABLE_CHOICE:
322			break;
323			default:
324			if (value == NULL) {
325			cmdq_error(cmdq, "empty value");
326			return (-1);
327			}
328			}
329
330			o = NULL;
331			switch (oe->type) {
332			case OPTIONS_TABLE_STRING:
333			o = cmd_set_option_string(self, cmdq, oe, oo, value);
334			break;
335			case OPTIONS_TABLE_NUMBER:
336			o = cmd_set_option_number(self, cmdq, oe, oo, value);
337			break;
338			case OPTIONS_TABLE_KEY:
339			o = cmd_set_option_key(self, cmdq, oe, oo, value);
340			break;
341			case OPTIONS_TABLE_COLOUR:
342			o = cmd_set_option_colour(self, cmdq, oe, oo, value);
343			if (o != NULL)
344			style_update_new(oo, o->name, oe->style);
345			break;
346			case OPTIONS_TABLE_ATTRIBUTES:
347			o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
348			if (o != NULL)
349			style_update_new(oo, o->name, oe->style);
350			break;
351			case OPTIONS_TABLE_FLAG:
352			o = cmd_set_option_flag(self, cmdq, oe, oo, value);
353			break;
354			case OPTIONS_TABLE_CHOICE:
355			o = cmd_set_option_choice(self, cmdq, oe, oo, value);
356			break;
357			case OPTIONS_TABLE_STYLE:
358			o = cmd_set_option_style(self, cmdq, oe, oo, value);
359			break;
360			}
361			if (o == NULL)
362			return (-1);
363			return (0);
364			}
365
366			/* Set a string option. */
367			struct options_entry *
368			cmd_set_option_string(struct cmd self, __unused struct cmd_q cmdq,
369			const struct options_table_entry oe, struct options oo,
370			const char *value)
371			{
372			struct args *args = self->args;
373			struct options_entry *o;
374			char oldval, newval;
375
376			if (args_has(args, 'a')) {
377			oldval = options_get_string(oo, oe->name);
378			xasprintf(&newval, "%s%s", oldval, value);
379			} else
380			newval = xstrdup(value);
381
382			o = options_set_string(oo, oe->name, "%s", newval);
383
384			free(newval);
385			return (o);
386			}
387
388			/* Set a number option. */
389			struct options_entry *
390			cmd_set_option_number(__unused struct cmd self, struct cmd_q cmdq,
391			const struct options_table_entry oe, struct options oo,
392			const char *value)
393			{
394			long long ll;
395			const char *errstr;
396
397			ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
398			if (errstr != NULL) {
399			cmdq_error(cmdq, "value is %s: %s", errstr, value);
400			return (NULL);
401			}
402
403			return (options_set_number(oo, oe->name, ll));
404			}
405
406			/* Set a key option. */
407			struct options_entry *
408			cmd_set_option_key(__unused struct cmd self, struct cmd_q cmdq,
409			const struct options_table_entry oe, struct options oo,
410			const char *value)
411			{
412			key_code key;
413
414			key = key_string_lookup_string(value);
415			if (key == KEYC_UNKNOWN) {
416			cmdq_error(cmdq, "bad key: %s", value);
417			return (NULL);
418			}
419
420			return (options_set_number(oo, oe->name, key));
421			}
422
423			/* Set a colour option. */
424			struct options_entry *
425			cmd_set_option_colour(__unused struct cmd self, struct cmd_q cmdq,
426			const struct options_table_entry oe, struct options oo,
427			const char *value)
428			{
429			int colour;
430
431			if ((colour = colour_fromstring(value)) == -1) {
432			cmdq_error(cmdq, "bad colour: %s", value);
433			return (NULL);
434			}
435
436			return (options_set_number(oo, oe->name, colour));
437			}
438
439			/* Set an attributes option. */
440			struct options_entry *
441			cmd_set_option_attributes(__unused struct cmd self, struct cmd_q cmdq,
442			const struct options_table_entry oe, struct options oo,
443			const char *value)
444			{
445			int attr;
446
447			if ((attr = attributes_fromstring(value)) == -1) {
448			cmdq_error(cmdq, "bad attributes: %s", value);
449			return (NULL);
450			}
451
452			return (options_set_number(oo, oe->name, attr));
453			}
454
455			/* Set a flag option. */
456			struct options_entry *
457			cmd_set_option_flag(__unused struct cmd self, struct cmd_q cmdq,
458			const struct options_table_entry oe, struct options oo,
459			const char *value)
460			{
461			int flag;
462
463			if (value == NULL \|\| *value == '\0')
464			flag = !options_get_number(oo, oe->name);
465			else {
466			if ((value[0] == '1' && value[1] == '\0') \|\|
467			strcasecmp(value, "on") == 0 \|\|
468			strcasecmp(value, "yes") == 0)
469			flag = 1;
470			else if ((value[0] == '0' && value[1] == '\0') \|\|
471			strcasecmp(value, "off") == 0 \|\|
472			strcasecmp(value, "no") == 0)
473			flag = 0;
474			else {
475			cmdq_error(cmdq, "bad value: %s", value);
476			return (NULL);
477			}
478			}
479
480			return (options_set_number(oo, oe->name, flag));
481			}
482
483			/* Set a choice option. */
484			struct options_entry *
485			cmd_set_option_choice(__unused struct cmd self, struct cmd_q cmdq,
486			const struct options_table_entry oe, struct options oo,
487			const char *value)
488			{
489			const char **choicep;
490			int n, choice = -1;
491
492			if (value == NULL) {
493			choice = options_get_number(oo, oe->name);
494			if (choice < 2)
495			choice = !choice;
496			} else {
497			n = 0;
498			for (choicep = oe->choices; *choicep != NULL; choicep++) {
499			n++;
500			if (strncmp(*choicep, value, strlen(value)) != 0)
501			continue;
502
503			if (choice != -1) {
504			cmdq_error(cmdq, "ambiguous value: %s", value);
505			return (NULL);
506			}
507			choice = n - 1;
508			}
509			if (choice == -1) {
510			cmdq_error(cmdq, "unknown value: %s", value);
511			return (NULL);
512			}
513			}
514
515			return (options_set_number(oo, oe->name, choice));
516			}
517
518			/* Set a style option. */
519			struct options_entry *
520			cmd_set_option_style(struct cmd self, struct cmd_q cmdq,
521			const struct options_table_entry oe, struct options oo,
522			const char *value)
523			{
524			struct args *args = self->args;
525			struct options_entry *o;
526			int append;
527
528			append = args_has(args, 'a');
529			if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
530			cmdq_error(cmdq, "bad style: %s", value);
531			return (NULL);
532			}
533
534			style_update_old(oo, oe->name, &o->style);
535			return (o);
536			}