Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/tmux/options.c	Lines:	0	303	0.0 %
Date:	2017-11-13	Branches:	0	437	0.0 %


/* $OpenBSD: options.c,v 1.36 2017/08/09 13:44:36 nicm Exp $ */

/*
 * Copyright (c) 2008 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 <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#include "tmux.h"

/*
 * Option handling; each option has a name, type and value and is stored in
 * a red-black tree.
 */

struct options_entry {
	struct options				 *owner;

	const char				 *name;
	const struct options_table_entry	 *tableentry;

	union {
		char				 *string;
		long long			  number;
		struct grid_cell		  style;
		struct {
			const char		**array;
			u_int			  arraysize;
		};
	};

	RB_ENTRY(options_entry)			  entry;
};

struct options {
	RB_HEAD(options_tree, options_entry)	 tree;
	struct options				*parent;
};

static struct options_entry	*options_add(struct options *, const char *);

#define OPTIONS_ARRAY_LIMIT 1000

#define OPTIONS_IS_STRING(o)						\
	((o)->tableentry == NULL ||					\
	    (o)->tableentry->type == OPTIONS_TABLE_STRING)
#define OPTIONS_IS_NUMBER(o) \
	((o)->tableentry != NULL &&					\
	    ((o)->tableentry->type == OPTIONS_TABLE_NUMBER ||		\
	    (o)->tableentry->type == OPTIONS_TABLE_KEY ||		\
	    (o)->tableentry->type == OPTIONS_TABLE_COLOUR ||		\
	    (o)->tableentry->type == OPTIONS_TABLE_ATTRIBUTES ||	\
	    (o)->tableentry->type == OPTIONS_TABLE_FLAG ||		\
	    (o)->tableentry->type == OPTIONS_TABLE_CHOICE))
#define OPTIONS_IS_STYLE(o) \
	((o)->tableentry != NULL &&					\
	    (o)->tableentry->type == OPTIONS_TABLE_STYLE)
#define OPTIONS_IS_ARRAY(o) \
	((o)->tableentry != NULL &&					\
	    (o)->tableentry->type == OPTIONS_TABLE_ARRAY)

static int	options_cmp(struct options_entry *, struct options_entry *);
RB_GENERATE_STATIC(options_tree, options_entry, entry, options_cmp);

static int
options_cmp(struct options_entry *lhs, struct options_entry *rhs)
{
	return (strcmp(lhs->name, rhs->name));
}

static const struct options_table_entry *
options_parent_table_entry(struct options *oo, const char *s)
{
	struct options_entry	*o;

	if (oo->parent == NULL)
		fatalx("no parent options for %s", s);
	o = options_get_only(oo->parent, s);
	if (o == NULL)
		fatalx("%s not in parent options", s);
	return (o->tableentry);
}

struct options *
options_create(struct options *parent)
{
	struct options	*oo;

	oo = xcalloc(1, sizeof *oo);
	RB_INIT(&oo->tree);
	oo->parent = parent;
	return (oo);
}

void
options_free(struct options *oo)
{
	struct options_entry	*o, *tmp;

	RB_FOREACH_SAFE(o, options_tree, &oo->tree, tmp)
		options_remove(o);
	free(oo);
}

struct options_entry *
options_first(struct options *oo)
{
	return (RB_MIN(options_tree, &oo->tree));
}

struct options_entry *
options_next(struct options_entry *o)
{
	return (RB_NEXT(options_tree, &oo->tree, o));
}

struct options_entry *
options_get_only(struct options *oo, const char *name)
{
	struct options_entry	o;

	o.name = name;
	return (RB_FIND(options_tree, &oo->tree, &o));
}

struct options_entry *
options_get(struct options *oo, const char *name)
{
	struct options_entry	*o;

	o = options_get_only(oo, name);
	while (o == NULL) {
		oo = oo->parent;
		if (oo == NULL)
			break;
		o = options_get_only(oo, name);
	}
	return (o);
}

struct options_entry *
options_empty(struct options *oo, const struct options_table_entry *oe)
{
	struct options_entry	*o;

	o = options_add(oo, oe->name);
	o->tableentry = oe;

	return (o);
}

struct options_entry *
options_default(struct options *oo, const struct options_table_entry *oe)
{
	struct options_entry	*o;

	o = options_empty(oo, oe);
	if (oe->type == OPTIONS_TABLE_ARRAY)
		options_array_assign(o, oe->default_str);
	else if (oe->type == OPTIONS_TABLE_STRING)
		o->string = xstrdup(oe->default_str);
	else if (oe->type == OPTIONS_TABLE_STYLE) {
		memcpy(&o->style, &grid_default_cell, sizeof o->style);
		style_parse(&grid_default_cell, &o->style, oe->default_str);
	} else
		o->number = oe->default_num;
	return (o);
}

static struct options_entry *
options_add(struct options *oo, const char *name)
{
	struct options_entry	*o;

	o = options_get_only(oo, name);
	if (o != NULL)
		options_remove(o);

	o = xcalloc(1, sizeof *o);
	o->owner = oo;
	o->name = xstrdup(name);

	RB_INSERT(options_tree, &oo->tree, o);
	return (o);
}

void
options_remove(struct options_entry *o)
{
	struct options	*oo = o->owner;
	u_int		 i;

	if (OPTIONS_IS_STRING(o))
		free((void *)o->string);
	else if (OPTIONS_IS_ARRAY(o)) {
		for (i = 0; i < o->arraysize; i++)
			free((void *)o->array[i]);
		free(o->array);
	}

	RB_REMOVE(options_tree, &oo->tree, o);
	free(o);
}

const char *
options_name(struct options_entry *o)
{
	return (o->name);
}

const struct options_table_entry *
options_table_entry(struct options_entry *o)
{
	return (o->tableentry);
}

void
options_array_clear(struct options_entry *o)
{
	if (OPTIONS_IS_ARRAY(o))
		o->arraysize = 0;
}

const char *
options_array_get(struct options_entry *o, u_int idx)
{
	if (!OPTIONS_IS_ARRAY(o))
		return (NULL);
	if (idx >= o->arraysize)
		return (NULL);
	return (o->array[idx]);
}

int
options_array_set(struct options_entry *o, u_int idx, const char *value,
    int append)
{
	char	*new;
	u_int	 i;

	if (!OPTIONS_IS_ARRAY(o))
		return (-1);

	if (idx >= OPTIONS_ARRAY_LIMIT)
		return (-1);
	if (idx >= o->arraysize) {
		o->array = xreallocarray(o->array, idx + 1, sizeof *o->array);
		for (i = o->arraysize; i < idx + 1; i++)
			o->array[i] = NULL;
		o->arraysize = idx + 1;
	}

	new = NULL;
	if (value != NULL) {
		if (o->array[idx] != NULL && append)
			xasprintf(&new, "%s%s", o->array[idx], value);
		else
			new = xstrdup(value);
	}

	free((void *)o->array[idx]);
	o->array[idx] = new;
	return (0);
}

int
options_array_size(struct options_entry *o, u_int *size)
{
	if (!OPTIONS_IS_ARRAY(o))
		return (-1);
	if (size != NULL)
		*size = o->arraysize;
	return (0);
}

void
options_array_assign(struct options_entry *o, const char *s)
{
	const char	*separator;
	char		*copy, *next, *string;
	u_int		 i;

	separator = o->tableentry->separator;
	if (separator == NULL)
		separator = " ,";

	copy = string = xstrdup(s);
	while ((next = strsep(&string, separator)) != NULL) {
		if (*next == '\0')
			continue;
		for (i = 0; i < OPTIONS_ARRAY_LIMIT; i++) {
			if (i >= o->arraysize || o->array[i] == NULL)
				break;
		}
		if (i == OPTIONS_ARRAY_LIMIT)
			break;
		options_array_set(o, i, next, 0);
	}
	free(copy);
}

int
options_isstring(struct options_entry *o)
{
	if (o->tableentry == NULL)
		return (1);
	return (OPTIONS_IS_STRING(o) || OPTIONS_IS_ARRAY(o));
}

const char *
options_tostring(struct options_entry *o, int idx, int numeric)
{
	static char	 s[1024];
	const char	*tmp;

	if (OPTIONS_IS_ARRAY(o)) {
		if (idx == -1)
			return (NULL);
		if ((u_int)idx >= o->arraysize || o->array[idx] == NULL)
			return ("");
		return (o->array[idx]);
	}
	if (OPTIONS_IS_STYLE(o))
		return (style_tostring(&o->style));
	if (OPTIONS_IS_NUMBER(o)) {
		tmp = NULL;
		switch (o->tableentry->type) {
		case OPTIONS_TABLE_NUMBER:
			xsnprintf(s, sizeof s, "%lld", o->number);
			break;
		case OPTIONS_TABLE_KEY:
			tmp = key_string_lookup_key(o->number);
			break;
		case OPTIONS_TABLE_COLOUR:
			tmp = colour_tostring(o->number);
			break;
		case OPTIONS_TABLE_ATTRIBUTES:
			tmp = attributes_tostring(o->number);
			break;
		case OPTIONS_TABLE_FLAG:
			if (numeric)
				xsnprintf(s, sizeof s, "%lld", o->number);
			else
				tmp = (o->number ? "on" : "off");
			break;
		case OPTIONS_TABLE_CHOICE:
			tmp = o->tableentry->choices[o->number];
			break;
		case OPTIONS_TABLE_STRING:
		case OPTIONS_TABLE_STYLE:
		case OPTIONS_TABLE_ARRAY:
			break;
		}
		if (tmp != NULL)
			xsnprintf(s, sizeof s, "%s", tmp);
		return (s);
	}
	if (OPTIONS_IS_STRING(o))
		return (o->string);
	return (NULL);
}

char *
options_parse(const char *name, int *idx)
{
	char	*copy, *cp, *end;

	if (*name == '\0')
		return (NULL);
	copy = xstrdup(name);
	if ((cp = strchr(copy, '[')) == NULL) {
		*idx = -1;
		return (copy);
	}
	end = strchr(cp + 1, ']');
	if (end == NULL || end[1] != '\0' || !isdigit((u_char)end[-1])) {
		free(copy);
		return (NULL);
	}
	if (sscanf(cp, "[%d]", idx) != 1 || *idx < 0) {
		free(copy);
		return (NULL);
	}
	*cp = '\0';
	return (copy);
}

struct options_entry *
options_parse_get(struct options *oo, const char *s, int *idx, int only)
{
	struct options_entry	*o;
	char			*name;

	name = options_parse(s, idx);
	if (name == NULL)
		return (NULL);
	if (only)
		o = options_get_only(oo, name);
	else
		o = options_get(oo, name);
	free(name);
	return (o);
}

char *
options_match(const char *s, int *idx, int* ambiguous)
{
	const struct options_table_entry	*oe, *found;
	char					*name;
	size_t					 namelen;

	name = options_parse(s, idx);
	if (name == NULL)
		return (NULL);
	namelen = strlen(name);

	if (*name == '@') {
		*ambiguous = 0;
		return (name);
	}

	found = NULL;
	for (oe = options_table; oe->name != NULL; oe++) {
		if (strcmp(oe->name, name) == 0) {
			found = oe;
			break;
		}
		if (strncmp(oe->name, name, namelen) == 0) {
			if (found != NULL) {
				*ambiguous = 1;
				free(name);
				return (NULL);
			}
			found = oe;
		}
	}
	free(name);
	if (found == NULL) {
		*ambiguous = 0;
		return (NULL);
	}
	return (xstrdup(found->name));
}

struct options_entry *
options_match_get(struct options *oo, const char *s, int *idx, int only,
    int* ambiguous)
{
	char			*name;
	struct options_entry	*o;

	name = options_match(s, idx, ambiguous);
	if (name == NULL)
		return (NULL);
	*ambiguous = 0;
	if (only)
		o = options_get_only(oo, name);
	else
		o = options_get(oo, name);
	free(name);
	return (o);
}

const char *
options_get_string(struct options *oo, const char *name)
{
	struct options_entry	*o;

	o = options_get(oo, name);
	if (o == NULL)
		fatalx("missing option %s", name);
	if (!OPTIONS_IS_STRING(o))
		fatalx("option %s is not a string", name);
	return (o->string);
}

long long
options_get_number(struct options *oo, const char *name)
{
	struct options_entry	*o;

	o = options_get(oo, name);
	if (o == NULL)
		fatalx("missing option %s", name);
	if (!OPTIONS_IS_NUMBER(o))
	    fatalx("option %s is not a number", name);
	return (o->number);
}

const struct grid_cell *
options_get_style(struct options *oo, const char *name)
{
	struct options_entry	*o;

	o = options_get(oo, name);
	if (o == NULL)
		fatalx("missing option %s", name);
	if (!OPTIONS_IS_STYLE(o))
		fatalx("option %s is not a style", name);
	return (&o->style);
}

struct options_entry *
options_set_string(struct options *oo, const char *name, int append,
    const char *fmt, ...)
{
	struct options_entry	*o;
	va_list			 ap;
	char			*s, *value;

	va_start(ap, fmt);
	xvasprintf(&s, fmt, ap);
	va_end(ap);

	o = options_get_only(oo, name);
	if (o != NULL && append && OPTIONS_IS_STRING(o)) {
		xasprintf(&value, "%s%s", o->string, s);
		free(s);
	} else
		value = s;
	if (o == NULL && *name == '@')
		o = options_add(oo, name);
	else if (o == NULL) {
		o = options_default(oo, options_parent_table_entry(oo, name));
		if (o == NULL)
			return (NULL);
	}

	if (!OPTIONS_IS_STRING(o))
		fatalx("option %s is not a string", name);
	free(o->string);
	o->string = value;
	return (o);
}

struct options_entry *
options_set_number(struct options *oo, const char *name, long long value)
{
	struct options_entry	*o;

	if (*name == '@')
		fatalx("user option %s must be a string", name);

	o = options_get_only(oo, name);
	if (o == NULL) {
		o = options_default(oo, options_parent_table_entry(oo, name));
		if (o == NULL)
			return (NULL);
	}

	if (!OPTIONS_IS_NUMBER(o))
		fatalx("option %s is not a number", name);
	o->number = value;
	return (o);
}

struct options_entry *
options_set_style(struct options *oo, const char *name, int append,
    const char *value)
{
	struct options_entry	*o;
	struct grid_cell	 gc;

	if (*name == '@')
		fatalx("user option %s must be a string", name);

	o = options_get_only(oo, name);
	if (o != NULL && append && OPTIONS_IS_STYLE(o))
		memcpy(&gc, &o->style, sizeof gc);
	else
		memcpy(&gc, &grid_default_cell, sizeof gc);
	if (style_parse(&grid_default_cell, &gc, value) == -1)
		return (NULL);
	if (o == NULL) {
		o = options_default(oo, options_parent_table_entry(oo, name));
		if (o == NULL)
			return (NULL);
	}

	if (!OPTIONS_IS_STYLE(o))
		fatalx("option %s is not a style", name);
	memcpy(&o->style, &gc, sizeof o->style);
	return (o);
}

enum options_table_scope
options_scope_from_flags(struct args *args, int window,
    struct cmd_find_state *fs, struct options **oo, char **cause)
{
	struct session	*s = fs->s;
	struct winlink	*wl = fs->wl;
	const char	*target= args_get(args, 't');

	if (args_has(args, 's')) {
		*oo = global_options;
		return (OPTIONS_TABLE_SERVER);
	}

	if (window || args_has(args, 'w')) {
		if (args_has(args, 'g')) {
			*oo = global_w_options;
			return (OPTIONS_TABLE_WINDOW);
		}
		if (wl == NULL) {
			if (target != NULL)
				xasprintf(cause, "no such window: %s", target);
			else
				xasprintf(cause, "no current window");
			return (OPTIONS_TABLE_NONE);
		}
		*oo = wl->window->options;
		return (OPTIONS_TABLE_WINDOW);
	} else {
		if (args_has(args, 'g')) {
			*oo = global_s_options;
			return (OPTIONS_TABLE_SESSION);
		}
		if (s == NULL) {
			if (target != NULL)
				xasprintf(cause, "no such session: %s", target);
			else
				xasprintf(cause, "no current session");
			return (OPTIONS_TABLE_NONE);
		}
		*oo = s->options;
		return (OPTIONS_TABLE_SESSION);
	}
}

void
options_style_update_new(struct options *oo, struct options_entry *o)
{
	const char		*newname = o->tableentry->style;
	struct options_entry	*new;

	if (newname == NULL)
		return;
	new = options_get_only(oo, newname);
	if (new == NULL)
		new = options_set_style(oo, newname, 0, "default");

	if (strstr(o->name, "-bg") != NULL)
		new->style.bg = o->number;
	else if (strstr(o->name, "-fg") != NULL)
		new->style.fg = o->number;
	else if (strstr(o->name, "-attr") != NULL)
		new->style.attr = o->number;
}

void
options_style_update_old(struct options *oo, struct options_entry *o)
{
	char	newname[128];
	int	size;

	size = strrchr(o->name, '-') - o->name;

	xsnprintf(newname, sizeof newname, "%.*s-bg", size, o->name);
	if (options_get(oo, newname) != NULL)
		options_set_number(oo, newname, o->style.bg);

	xsnprintf(newname, sizeof newname, "%.*s-fg", size, o->name);
	if (options_get(oo, newname) != NULL)
		options_set_number(oo, newname, o->style.fg);

	xsnprintf(newname, sizeof newname, "%.*s-attr", size, o->name);
	if (options_get(oo, newname) != NULL)
		options_set_number(oo, newname, o->style.attr);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: options.c,v 1.36 2017/08/09 13:44:36 nicm Exp $ */
2
3			/*
4			* Copyright (c) 2008 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 <ctype.h>
22			#include <stdarg.h>
23			#include <stdlib.h>
24			#include <string.h>
25
26			#include "tmux.h"
27
28			/*
29			* Option handling; each option has a name, type and value and is stored in
30			* a red-black tree.
31			*/
32
33			struct options_entry {
34			struct options *owner;
35
36			const char *name;
37			const struct options_table_entry *tableentry;
38
39			union {
40			char *string;
41			long long number;
42			struct grid_cell style;
43			struct {
44			const char **array;
45			u_int arraysize;
46			};
47			};
48
49			RB_ENTRY(options_entry) entry;
50			};
51
52			struct options {
53			RB_HEAD(options_tree, options_entry) tree;
54			struct options *parent;
55			};
56
57			static struct options_entry options_add(struct options , const char *);
58
59			#define OPTIONS_ARRAY_LIMIT 1000
60
61			#define OPTIONS_IS_STRING(o) \
62			((o)->tableentry == NULL \|\| \
63			(o)->tableentry->type == OPTIONS_TABLE_STRING)
64			#define OPTIONS_IS_NUMBER(o) \
65			((o)->tableentry != NULL && \
66			((o)->tableentry->type == OPTIONS_TABLE_NUMBER \|\| \
67			(o)->tableentry->type == OPTIONS_TABLE_KEY \|\| \
68			(o)->tableentry->type == OPTIONS_TABLE_COLOUR \|\| \
69			(o)->tableentry->type == OPTIONS_TABLE_ATTRIBUTES \|\| \
70			(o)->tableentry->type == OPTIONS_TABLE_FLAG \|\| \
71			(o)->tableentry->type == OPTIONS_TABLE_CHOICE))
72			#define OPTIONS_IS_STYLE(o) \
73			((o)->tableentry != NULL && \
74			(o)->tableentry->type == OPTIONS_TABLE_STYLE)
75			#define OPTIONS_IS_ARRAY(o) \
76			((o)->tableentry != NULL && \
77			(o)->tableentry->type == OPTIONS_TABLE_ARRAY)
78
79			static int options_cmp(struct options_entry , struct options_entry );
80			RB_GENERATE_STATIC(options_tree, options_entry, entry, options_cmp);
81
82			static int
83			options_cmp(struct options_entry lhs, struct options_entry rhs)
84			{
85			return (strcmp(lhs->name, rhs->name));
86			}
87
88			static const struct options_table_entry *
89			options_parent_table_entry(struct options oo, const char s)
90			{
91			struct options_entry *o;
92
93			if (oo->parent == NULL)
94			fatalx("no parent options for %s", s);
95			o = options_get_only(oo->parent, s);
96			if (o == NULL)
97			fatalx("%s not in parent options", s);
98			return (o->tableentry);
99			}
100
101			struct options *
102			options_create(struct options *parent)
103			{
104			struct options *oo;
105
106			oo = xcalloc(1, sizeof *oo);
107			RB_INIT(&oo->tree);
108			oo->parent = parent;
109			return (oo);
110			}
111
112			void
113			options_free(struct options *oo)
114			{
115			struct options_entry o, tmp;
116
117			RB_FOREACH_SAFE(o, options_tree, &oo->tree, tmp)
118			options_remove(o);
119			free(oo);
120			}
121
122			struct options_entry *
123			options_first(struct options *oo)
124			{
125			return (RB_MIN(options_tree, &oo->tree));
126			}
127
128			struct options_entry *
129			options_next(struct options_entry *o)
130			{
131			return (RB_NEXT(options_tree, &oo->tree, o));
132			}
133
134			struct options_entry *
135			options_get_only(struct options oo, const char name)
136			{
137			struct options_entry o;
138
139			o.name = name;
140			return (RB_FIND(options_tree, &oo->tree, &o));
141			}
142
143			struct options_entry *
144			options_get(struct options oo, const char name)
145			{
146			struct options_entry *o;
147
148			o = options_get_only(oo, name);
149			while (o == NULL) {
150			oo = oo->parent;
151			if (oo == NULL)
152			break;
153			o = options_get_only(oo, name);
154			}
155			return (o);
156			}
157
158			struct options_entry *
159			options_empty(struct options oo, const struct options_table_entry oe)
160			{
161			struct options_entry *o;
162
163			o = options_add(oo, oe->name);
164			o->tableentry = oe;
165
166			return (o);
167			}
168
169			struct options_entry *
170			options_default(struct options oo, const struct options_table_entry oe)
171			{
172			struct options_entry *o;
173
174			o = options_empty(oo, oe);
175			if (oe->type == OPTIONS_TABLE_ARRAY)
176			options_array_assign(o, oe->default_str);
177			else if (oe->type == OPTIONS_TABLE_STRING)
178			o->string = xstrdup(oe->default_str);
179			else if (oe->type == OPTIONS_TABLE_STYLE) {
180			memcpy(&o->style, &grid_default_cell, sizeof o->style);
181			style_parse(&grid_default_cell, &o->style, oe->default_str);
182			} else
183			o->number = oe->default_num;
184			return (o);
185			}
186
187			static struct options_entry *
188			options_add(struct options oo, const char name)
189			{
190			struct options_entry *o;
191
192			o = options_get_only(oo, name);
193			if (o != NULL)
194			options_remove(o);
195
196			o = xcalloc(1, sizeof *o);
197			o->owner = oo;
198			o->name = xstrdup(name);
199
200			RB_INSERT(options_tree, &oo->tree, o);
201			return (o);
202			}
203
204			void
205			options_remove(struct options_entry *o)
206			{
207			struct options *oo = o->owner;
208			u_int i;
209
210			if (OPTIONS_IS_STRING(o))
211			free((void *)o->string);
212			else if (OPTIONS_IS_ARRAY(o)) {
213			for (i = 0; i < o->arraysize; i++)
214			free((void *)o->array[i]);
215			free(o->array);
216			}
217
218			RB_REMOVE(options_tree, &oo->tree, o);
219			free(o);
220			}
221
222			const char *
223			options_name(struct options_entry *o)
224			{
225			return (o->name);
226			}
227
228			const struct options_table_entry *
229			options_table_entry(struct options_entry *o)
230			{
231			return (o->tableentry);
232			}
233
234			void
235			options_array_clear(struct options_entry *o)
236			{
237			if (OPTIONS_IS_ARRAY(o))
238			o->arraysize = 0;
239			}
240
241			const char *
242			options_array_get(struct options_entry *o, u_int idx)
243			{
244			if (!OPTIONS_IS_ARRAY(o))
245			return (NULL);
246			if (idx >= o->arraysize)
247			return (NULL);
248			return (o->array[idx]);
249			}
250
251			int
252			options_array_set(struct options_entry o, u_int idx, const char value,
253			int append)
254			{
255			char *new;
256			u_int i;
257
258			if (!OPTIONS_IS_ARRAY(o))
259			return (-1);
260
261			if (idx >= OPTIONS_ARRAY_LIMIT)
262			return (-1);
263			if (idx >= o->arraysize) {
264			o->array = xreallocarray(o->array, idx + 1, sizeof *o->array);
265			for (i = o->arraysize; i < idx + 1; i++)
266			o->array[i] = NULL;
267			o->arraysize = idx + 1;
268			}
269
270			new = NULL;
271			if (value != NULL) {
272			if (o->array[idx] != NULL && append)
273			xasprintf(&new, "%s%s", o->array[idx], value);
274			else
275			new = xstrdup(value);
276			}
277
278			free((void *)o->array[idx]);
279			o->array[idx] = new;
280			return (0);
281			}
282
283			int
284			options_array_size(struct options_entry o, u_int size)
285			{
286			if (!OPTIONS_IS_ARRAY(o))
287			return (-1);
288			if (size != NULL)
289			*size = o->arraysize;
290			return (0);
291			}
292
293			void
294			options_array_assign(struct options_entry o, const char s)
295			{
296			const char *separator;
297			char copy, next, *string;
298			u_int i;
299
300			separator = o->tableentry->separator;
301			if (separator == NULL)
302			separator = " ,";
303
304			copy = string = xstrdup(s);
305			while ((next = strsep(&string, separator)) != NULL) {
306			if (*next == '\0')
307			continue;
308			for (i = 0; i < OPTIONS_ARRAY_LIMIT; i++) {
309			if (i >= o->arraysize \|\| o->array[i] == NULL)
310			break;
311			}
312			if (i == OPTIONS_ARRAY_LIMIT)
313			break;
314			options_array_set(o, i, next, 0);
315			}
316			free(copy);
317			}
318
319			int
320			options_isstring(struct options_entry *o)
321			{
322			if (o->tableentry == NULL)
323			return (1);
324			return (OPTIONS_IS_STRING(o) \|\| OPTIONS_IS_ARRAY(o));
325			}
326
327			const char *
328			options_tostring(struct options_entry *o, int idx, int numeric)
329			{
330			static char s[1024];
331			const char *tmp;
332
333			if (OPTIONS_IS_ARRAY(o)) {
334			if (idx == -1)
335			return (NULL);
336			if ((u_int)idx >= o->arraysize \|\| o->array[idx] == NULL)
337			return ("");
338			return (o->array[idx]);
339			}
340			if (OPTIONS_IS_STYLE(o))
341			return (style_tostring(&o->style));
342			if (OPTIONS_IS_NUMBER(o)) {
343			tmp = NULL;
344			switch (o->tableentry->type) {
345			case OPTIONS_TABLE_NUMBER:
346			xsnprintf(s, sizeof s, "%lld", o->number);
347			break;
348			case OPTIONS_TABLE_KEY:
349			tmp = key_string_lookup_key(o->number);
350			break;
351			case OPTIONS_TABLE_COLOUR:
352			tmp = colour_tostring(o->number);
353			break;
354			case OPTIONS_TABLE_ATTRIBUTES:
355			tmp = attributes_tostring(o->number);
356			break;
357			case OPTIONS_TABLE_FLAG:
358			if (numeric)
359			xsnprintf(s, sizeof s, "%lld", o->number);
360			else
361			tmp = (o->number ? "on" : "off");
362			break;
363			case OPTIONS_TABLE_CHOICE:
364			tmp = o->tableentry->choices[o->number];
365			break;
366			case OPTIONS_TABLE_STRING:
367			case OPTIONS_TABLE_STYLE:
368			case OPTIONS_TABLE_ARRAY:
369			break;
370			}
371			if (tmp != NULL)
372			xsnprintf(s, sizeof s, "%s", tmp);
373			return (s);
374			}
375			if (OPTIONS_IS_STRING(o))
376			return (o->string);
377			return (NULL);
378			}
379
380			char *
381			options_parse(const char name, int idx)
382			{
383			char copy, cp, *end;
384
385			if (*name == '\0')
386			return (NULL);
387			copy = xstrdup(name);
388			if ((cp = strchr(copy, '[')) == NULL) {
389			*idx = -1;
390			return (copy);
391			}
392			end = strchr(cp + 1, ']');
393			if (end == NULL \|\| end[1] != '\0' \|\| !isdigit((u_char)end[-1])) {
394			free(copy);
395			return (NULL);
396			}
397			if (sscanf(cp, "[%d]", idx) != 1 \|\| *idx < 0) {
398			free(copy);
399			return (NULL);
400			}
401			*cp = '\0';
402			return (copy);
403			}
404
405			struct options_entry *
406			options_parse_get(struct options oo, const char s, int *idx, int only)
407			{
408			struct options_entry *o;
409			char *name;
410
411			name = options_parse(s, idx);
412			if (name == NULL)
413			return (NULL);
414			if (only)
415			o = options_get_only(oo, name);
416			else
417			o = options_get(oo, name);
418			free(name);
419			return (o);
420			}
421
422			char *
423			options_match(const char s, int idx, int* ambiguous)
424			{
425			const struct options_table_entry oe, found;
426			char *name;
427			size_t namelen;
428
429			name = options_parse(s, idx);
430			if (name == NULL)
431			return (NULL);
432			namelen = strlen(name);
433
434			if (*name == '@') {
435			*ambiguous = 0;
436			return (name);
437			}
438
439			found = NULL;
440			for (oe = options_table; oe->name != NULL; oe++) {
441			if (strcmp(oe->name, name) == 0) {
442			found = oe;
443			break;
444			}
445			if (strncmp(oe->name, name, namelen) == 0) {
446			if (found != NULL) {
447			*ambiguous = 1;
448			free(name);
449			return (NULL);
450			}
451			found = oe;
452			}
453			}
454			free(name);
455			if (found == NULL) {
456			*ambiguous = 0;
457			return (NULL);
458			}
459			return (xstrdup(found->name));
460			}
461
462			struct options_entry *
463			options_match_get(struct options oo, const char s, int *idx, int only,
464			int* ambiguous)
465			{
466			char *name;
467			struct options_entry *o;
468
469			name = options_match(s, idx, ambiguous);
470			if (name == NULL)
471			return (NULL);
472			*ambiguous = 0;
473			if (only)
474			o = options_get_only(oo, name);
475			else
476			o = options_get(oo, name);
477			free(name);
478			return (o);
479			}
480
481			const char *
482			options_get_string(struct options oo, const char name)
483			{
484			struct options_entry *o;
485
486			o = options_get(oo, name);
487			if (o == NULL)
488			fatalx("missing option %s", name);
489			if (!OPTIONS_IS_STRING(o))
490			fatalx("option %s is not a string", name);
491			return (o->string);
492			}
493
494			long long
495			options_get_number(struct options oo, const char name)
496			{
497			struct options_entry *o;
498
499			o = options_get(oo, name);
500			if (o == NULL)
501			fatalx("missing option %s", name);
502			if (!OPTIONS_IS_NUMBER(o))
503			fatalx("option %s is not a number", name);
504			return (o->number);
505			}
506
507			const struct grid_cell *
508			options_get_style(struct options oo, const char name)
509			{
510			struct options_entry *o;
511
512			o = options_get(oo, name);
513			if (o == NULL)
514			fatalx("missing option %s", name);
515			if (!OPTIONS_IS_STYLE(o))
516			fatalx("option %s is not a style", name);
517			return (&o->style);
518			}
519
520			struct options_entry *
521			options_set_string(struct options oo, const char name, int append,
522			const char *fmt, ...)
523			{
524			struct options_entry *o;
525			va_list ap;
526			char s, value;
527
528			va_start(ap, fmt);
529			xvasprintf(&s, fmt, ap);
530			va_end(ap);
531
532			o = options_get_only(oo, name);
533			if (o != NULL && append && OPTIONS_IS_STRING(o)) {
534			xasprintf(&value, "%s%s", o->string, s);
535			free(s);
536			} else
537			value = s;
538			if (o == NULL && *name == '@')
539			o = options_add(oo, name);
540			else if (o == NULL) {
541			o = options_default(oo, options_parent_table_entry(oo, name));
542			if (o == NULL)
543			return (NULL);
544			}
545
546			if (!OPTIONS_IS_STRING(o))
547			fatalx("option %s is not a string", name);
548			free(o->string);
549			o->string = value;
550			return (o);
551			}
552
553			struct options_entry *
554			options_set_number(struct options oo, const char name, long long value)
555			{
556			struct options_entry *o;
557
558			if (*name == '@')
559			fatalx("user option %s must be a string", name);
560
561			o = options_get_only(oo, name);
562			if (o == NULL) {
563			o = options_default(oo, options_parent_table_entry(oo, name));
564			if (o == NULL)
565			return (NULL);
566			}
567
568			if (!OPTIONS_IS_NUMBER(o))
569			fatalx("option %s is not a number", name);
570			o->number = value;
571			return (o);
572			}
573
574			struct options_entry *
575			options_set_style(struct options oo, const char name, int append,
576			const char *value)
577			{
578			struct options_entry *o;
579			struct grid_cell gc;
580
581			if (*name == '@')
582			fatalx("user option %s must be a string", name);
583
584			o = options_get_only(oo, name);
585			if (o != NULL && append && OPTIONS_IS_STYLE(o))
586			memcpy(&gc, &o->style, sizeof gc);
587			else
588			memcpy(&gc, &grid_default_cell, sizeof gc);
589			if (style_parse(&grid_default_cell, &gc, value) == -1)
590			return (NULL);
591			if (o == NULL) {
592			o = options_default(oo, options_parent_table_entry(oo, name));
593			if (o == NULL)
594			return (NULL);
595			}
596
597			if (!OPTIONS_IS_STYLE(o))
598			fatalx("option %s is not a style", name);
599			memcpy(&o->style, &gc, sizeof o->style);
600			return (o);
601			}
602
603			enum options_table_scope
604			options_scope_from_flags(struct args *args, int window,
605			struct cmd_find_state fs, struct options oo, char *cause)
606			{
607			struct session *s = fs->s;
608			struct winlink *wl = fs->wl;
609			const char *target= args_get(args, 't');
610
611			if (args_has(args, 's')) {
612			*oo = global_options;
613			return (OPTIONS_TABLE_SERVER);
614			}
615
616			if (window \|\| args_has(args, 'w')) {
617			if (args_has(args, 'g')) {
618			*oo = global_w_options;
619			return (OPTIONS_TABLE_WINDOW);
620			}
621			if (wl == NULL) {
622			if (target != NULL)
623			xasprintf(cause, "no such window: %s", target);
624			else
625			xasprintf(cause, "no current window");
626			return (OPTIONS_TABLE_NONE);
627			}
628			*oo = wl->window->options;
629			return (OPTIONS_TABLE_WINDOW);
630			} else {
631			if (args_has(args, 'g')) {
632			*oo = global_s_options;
633			return (OPTIONS_TABLE_SESSION);
634			}
635			if (s == NULL) {
636			if (target != NULL)
637			xasprintf(cause, "no such session: %s", target);
638			else
639			xasprintf(cause, "no current session");
640			return (OPTIONS_TABLE_NONE);
641			}
642			*oo = s->options;
643			return (OPTIONS_TABLE_SESSION);
644			}
645			}
646
647			void
648			options_style_update_new(struct options oo, struct options_entry o)
649			{
650			const char *newname = o->tableentry->style;
651			struct options_entry *new;
652
653			if (newname == NULL)
654			return;
655			new = options_get_only(oo, newname);
656			if (new == NULL)
657			new = options_set_style(oo, newname, 0, "default");
658
659			if (strstr(o->name, "-bg") != NULL)
660			new->style.bg = o->number;
661			else if (strstr(o->name, "-fg") != NULL)
662			new->style.fg = o->number;
663			else if (strstr(o->name, "-attr") != NULL)
664			new->style.attr = o->number;
665			}
666
667			void
668			options_style_update_old(struct options oo, struct options_entry o)
669			{
670			char newname[128];
671			int size;
672
673			size = strrchr(o->name, '-') - o->name;
674
675			xsnprintf(newname, sizeof newname, "%.*s-bg", size, o->name);
676			if (options_get(oo, newname) != NULL)
677			options_set_number(oo, newname, o->style.bg);
678
679			xsnprintf(newname, sizeof newname, "%.*s-fg", size, o->name);
680			if (options_get(oo, newname) != NULL)
681			options_set_number(oo, newname, o->style.fg);
682
683			xsnprintf(newname, sizeof newname, "%.*s-attr", size, o->name);
684			if (options_get(oo, newname) != NULL)
685			options_set_number(oo, newname, o->style.attr);
686			}