#include <sys/types.h>
#include <ctype.h>
#include <fnmatch.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "tmux.h"
struct options_array_item {
char *key;
union options_value value;
RB_ENTRY(options_array_item) entry;
};
static int
options_array_key_to_number(const char *key, u_int *idx)
{
const char *errstr;
long long n;
if (*key == '\0')
return (-1);
for (const char *cp = key; *cp != '\0'; cp++) {
if (!isdigit((u_char)*cp))
return (0);
}
n = strtonum(key, 0, UINT_MAX, &errstr);
if (errstr != NULL)
return (-1);
if (idx != NULL)
*idx = n;
return (1);
}
static char *
options_array_correct_key(const char *key)
{
u_int idx;
int numeric;
char *out;
numeric = options_array_key_to_number(key, &idx);
if (numeric == -1)
return (NULL);
if (numeric == 1) {
xasprintf(&out, "%u", idx);
return (out);
}
return (xstrdup(key));
}
static int
options_array_cmp(struct options_array_item *a1, struct options_array_item *a2)
{
u_int i1, i2;
int n1, n2;
n1 = options_array_key_to_number(a1->key, &i1);
n2 = options_array_key_to_number(a2->key, &i2);
if (n1 && n2) {
if (i1 < i2)
return (-1);
if (i1 > i2)
return (1);
return (0);
}
if (n1)
return (-1);
if (n2)
return (1);
return (strcmp(a1->key, a2->key));
}
RB_GENERATE_STATIC(options_array, options_array_item, entry, options_array_cmp);
struct options_entry {
struct options *owner;
const char *name;
const struct options_table_entry *tableentry;
union options_value value;
int cached;
struct style style;
void *monitor_data;
u_int fire_count;
time_t fire_time;
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 *);
static void options_remove(struct options_entry *);
#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_FLAG || \
(o)->tableentry->type == OPTIONS_TABLE_CHOICE))
#define OPTIONS_IS_COMMAND(o) \
((o)->tableentry != NULL && \
(o)->tableentry->type == OPTIONS_TABLE_COMMAND)
#define OPTIONS_IS_ARRAY(o) \
((o)->tableentry != NULL && \
((o)->tableentry->flags & OPTIONS_TABLE_IS_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 char *
options_map_name(const char *name)
{
const struct options_name_map *map;
for (map = options_other_names; map->from != NULL; map++) {
if (strcmp(map->from, name) == 0)
return (map->to);
}
return (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(oo->parent, s);
if (o == NULL)
fatalx("%s not in parent options", s);
return (o->tableentry);
}
static void
options_value_free(struct options_entry *o, union options_value *ov)
{
if (OPTIONS_IS_STRING(o))
free(ov->string);
if (OPTIONS_IS_COMMAND(o) && ov->cmdlist != NULL)
cmd_list_free(ov->cmdlist);
}
static char *
options_value_to_string(struct options_entry *o, union options_value *ov,
int numeric)
{
char *s;
if (OPTIONS_IS_COMMAND(o))
return (cmd_list_print(ov->cmdlist, 0));
if (OPTIONS_IS_NUMBER(o)) {
switch (o->tableentry->type) {
case OPTIONS_TABLE_NUMBER:
xasprintf(&s, "%lld", ov->number);
break;
case OPTIONS_TABLE_KEY:
s = xstrdup(key_string_lookup_key(ov->number, 0));
break;
case OPTIONS_TABLE_COLOUR:
s = xstrdup(colour_tostring(ov->number));
break;
case OPTIONS_TABLE_FLAG:
if (numeric)
xasprintf(&s, "%lld", ov->number);
else
s = xstrdup(ov->number ? "on" : "off");
break;
case OPTIONS_TABLE_CHOICE:
s = xstrdup(o->tableentry->choices[ov->number]);
break;
default:
fatalx("not a number option type");
}
return (s);
}
if (OPTIONS_IS_STRING(o))
return (xstrdup(ov->string));
return (xstrdup(""));
}
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 *
options_get_parent(struct options *oo)
{
return (oo->parent);
}
void
options_set_parent(struct options *oo, struct options *parent)
{
oo->parent = parent;
}
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 = { .name = name }, *found;
found = RB_FIND(options_tree, &oo->tree, &o);
if (found == NULL) {
o.name = options_map_name(name);
return (RB_FIND(options_tree, &oo->tree, &o));
}
return (found);
}
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;
if (oe->flags & OPTIONS_TABLE_IS_ARRAY)
RB_INIT(&o->value.array);
return (o);
}
struct options_entry *
options_default(struct options *oo, const struct options_table_entry *oe)
{
struct options_entry *o;
union options_value *ov;
char key[32];
u_int i;
struct cmd_parse_result *pr;
o = options_empty(oo, oe);
ov = &o->value;
if (oe->flags & OPTIONS_TABLE_IS_ARRAY) {
if (oe->default_arr == NULL) {
options_array_assign(o, oe->default_str, NULL);
return (o);
}
for (i = 0; oe->default_arr[i] != NULL; i++) {
xsnprintf(key, sizeof key, "%u", i);
options_array_set(o, key, oe->default_arr[i], 0, NULL);
}
return (o);
}
switch (oe->type) {
case OPTIONS_TABLE_STRING:
ov->string = xstrdup(oe->default_str);
break;
case OPTIONS_TABLE_COMMAND:
pr = cmd_parse_from_string(oe->default_str, NULL);
switch (pr->status) {
case CMD_PARSE_ERROR:
free(pr->error);
break;
case CMD_PARSE_SUCCESS:
ov->cmdlist = pr->cmdlist;
break;
}
break;
default:
ov->number = oe->default_num;
break;
}
return (o);
}
char *
options_default_to_string(const struct options_table_entry *oe)
{
char *s;
switch (oe->type) {
case OPTIONS_TABLE_STRING:
case OPTIONS_TABLE_COMMAND:
s = xstrdup(oe->default_str);
break;
case OPTIONS_TABLE_NUMBER:
xasprintf(&s, "%lld", oe->default_num);
break;
case OPTIONS_TABLE_KEY:
s = xstrdup(key_string_lookup_key(oe->default_num, 0));
break;
case OPTIONS_TABLE_COLOUR:
s = xstrdup(colour_tostring(oe->default_num));
break;
case OPTIONS_TABLE_FLAG:
s = xstrdup(oe->default_num ? "on" : "off");
break;
case OPTIONS_TABLE_CHOICE:
s = xstrdup(oe->choices[oe->default_num]);
break;
default:
fatalx("unknown option type");
}
return (s);
}
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);
}
static void
options_remove(struct options_entry *o)
{
struct options *oo = o->owner;
if (OPTIONS_IS_ARRAY(o))
options_array_clear(o);
else
options_value_free(o, &o->value);
if (o->monitor_data != NULL)
hooks_monitor_free(o->monitor_data);
RB_REMOVE(options_tree, &oo->tree, o);
free((void *)o->name);
free(o);
}
const char *
options_name(struct options_entry *o)
{
return (o->name);
}
struct options *
options_owner(struct options_entry *o)
{
return (o->owner);
}
void *
options_get_monitor_data(struct options_entry *o)
{
return (o->monitor_data);
}
void
options_set_monitor_data(struct options_entry *o, void *data)
{
o->monitor_data = data;
}
void
options_hook_fired(struct options_entry *o)
{
o->fire_count++;
o->fire_time = current_time;
}
u_int
options_get_fire_count(struct options_entry *o)
{
return (o->fire_count);
}
time_t
options_get_fire_time(struct options_entry *o)
{
return (o->fire_time);
}
const struct options_table_entry *
options_table_entry(struct options_entry *o)
{
return (o->tableentry);
}
static struct options_array_item *
options_array_item(struct options_entry *o, const char *key)
{
struct options_array_item a;
a.key = (char *)key;
return (RB_FIND(options_array, &o->value.array, &a));
}
static struct options_array_item *
options_array_new(struct options_entry *o, const char *key)
{
struct options_array_item *a;
a = xcalloc(1, sizeof *a);
a->key = xstrdup(key);
RB_INSERT(options_array, &o->value.array, a);
return (a);
}
static void
options_array_free(struct options_entry *o, struct options_array_item *a)
{
options_value_free(o, &a->value);
RB_REMOVE(options_array, &o->value.array, a);
free(a->key);
free(a);
}
void
options_array_clear(struct options_entry *o)
{
struct options_array_item *a, *a1;
if (!OPTIONS_IS_ARRAY(o))
return;
RB_FOREACH_SAFE(a, options_array, &o->value.array, a1)
options_array_free(o, a);
}
union options_value *
options_array_get(struct options_entry *o, const char *key)
{
struct options_array_item *a;
char *new_key;
if (!OPTIONS_IS_ARRAY(o))
return (NULL);
new_key = options_array_correct_key(key);
if (new_key == NULL)
return (NULL);
a = options_array_item(o, new_key);
free(new_key);
if (a == NULL)
return (NULL);
return (&a->value);
}
union options_value *
options_array_getv(struct options_entry *o, const char *fmt, ...)
{
union options_value *ov;
va_list ap;
char *key;
va_start(ap, fmt);
xvasprintf(&key, fmt, ap);
va_end(ap);
ov = options_array_get(o, key);
free(key);
return (ov);
}
int
options_array_set(struct options_entry *o, const char *key, const char *value,
int append, char **cause)
{
struct options_array_item *a;
char *new, *new_key;
struct cmd_parse_result *pr;
long long number;
if (!OPTIONS_IS_ARRAY(o)) {
if (cause != NULL)
*cause = xstrdup("not an array");
return (-1);
}
new_key = options_array_correct_key(key);
if (new_key == NULL) {
if (cause != NULL)
xasprintf(cause, "bad array key: %s", key);
return (-1);
}
if (value == NULL) {
a = options_array_item(o, new_key);
if (a != NULL)
options_array_free(o, a);
free(new_key);
return (0);
}
if (OPTIONS_IS_COMMAND(o)) {
pr = cmd_parse_from_string(value, NULL);
switch (pr->status) {
case CMD_PARSE_ERROR:
if (cause != NULL)
*cause = pr->error;
else
free(pr->error);
free(new_key);
return (-1);
case CMD_PARSE_SUCCESS:
break;
}
a = options_array_item(o, new_key);
if (a == NULL)
a = options_array_new(o, new_key);
else
options_value_free(o, &a->value);
a->value.cmdlist = pr->cmdlist;
free(new_key);
return (0);
}
if (OPTIONS_IS_STRING(o)) {
a = options_array_item(o, new_key);
if (a != NULL && append)
xasprintf(&new, "%s%s", a->value.string, value);
else
new = xstrdup(value);
if (a == NULL)
a = options_array_new(o, new_key);
else
options_value_free(o, &a->value);
a->value.string = new;
free(new_key);
return (0);
}
if (o->tableentry->type == OPTIONS_TABLE_COLOUR) {
if ((number = colour_fromstring(value)) == -1) {
xasprintf(cause, "bad colour: %s", value);
free(new_key);
return (-1);
}
a = options_array_item(o, new_key);
if (a == NULL)
a = options_array_new(o, new_key);
else
options_value_free(o, &a->value);
a->value.number = number;
free(new_key);
return (0);
}
if (cause != NULL)
*cause = xstrdup("wrong array type");
free(new_key);
return (-1);
}
int
options_array_assign(struct options_entry *o, const char *s, char **cause)
{
const char *separator;
char *copy, *next, *string;
char key[32];
u_int i;
separator = o->tableentry->separator;
if (separator == NULL)
separator = " ,";
if (*separator == '\0') {
if (*s == '\0')
return (0);
for (i = 0; i < UINT_MAX; i++) {
if (options_array_getv(o, "%u", i) == NULL)
break;
}
xsnprintf(key, sizeof key, "%u", i);
return (options_array_set(o, key, s, 0, cause));
}
if (*s == '\0')
return (0);
copy = string = xstrdup(s);
while ((next = strsep(&string, separator)) != NULL) {
if (*next == '\0')
continue;
for (i = 0; i < UINT_MAX; i++) {
if (options_array_getv(o, "%u", i) == NULL)
break;
}
if (i == UINT_MAX)
break;
xsnprintf(key, sizeof key, "%u", i);
if (options_array_set(o, key, next, 0, cause) != 0) {
free(copy);
return (-1);
}
}
free(copy);
return (0);
}
struct options_array_item *
options_array_first(struct options_entry *o)
{
if (!OPTIONS_IS_ARRAY(o))
return (NULL);
return (RB_MIN(options_array, &o->value.array));
}
struct options_array_item *
options_array_next(struct options_array_item *a)
{
return (RB_NEXT(options_array, , a));
}
const char *
options_array_item_key(struct options_array_item *a)
{
return (a->key);
}
union options_value *
options_array_item_value(struct options_array_item *a)
{
return (&a->value);
}
int
options_is_array(struct options_entry *o)
{
return (OPTIONS_IS_ARRAY(o));
}
int
options_is_string(struct options_entry *o)
{
return (OPTIONS_IS_STRING(o));
}
char *
options_to_string(struct options_entry *o, const char *key, int numeric)
{
struct options_array_item *a;
char *result = NULL;
char *last = NULL;
char *next;
char *new_key;
if (OPTIONS_IS_ARRAY(o)) {
if (key == NULL) {
RB_FOREACH(a, options_array, &o->value.array) {
next = options_value_to_string(o, &a->value,
numeric);
if (last == NULL)
result = next;
else {
xasprintf(&result, "%s %s", last, next);
free(last);
free(next);
}
last = result;
}
if (result == NULL)
return (xstrdup(""));
return (result);
}
new_key = options_array_correct_key(key);
if (new_key == NULL)
return (xstrdup(""));
a = options_array_item(o, new_key);
free(new_key);
if (a == NULL)
return (xstrdup(""));
return (options_value_to_string(o, &a->value, numeric));
}
return (options_value_to_string(o, &o->value, numeric));
}
char *
options_parse(const char *name, char **key)
{
char *copy, *cp, *end, *raw, *new_key;
if (*name == '\0')
return (NULL);
*key = NULL;
copy = xstrdup(name);
if ((cp = strchr(copy, '[')) == NULL) {
return (copy);
}
end = strchr(cp + 1, ']');
if (end == NULL || end[1] != '\0' || end == cp + 1) {
free(copy);
return (NULL);
}
raw = xstrndup(cp + 1, end - (cp + 1));
new_key = options_array_correct_key(raw);
free(raw);
if (new_key == NULL) {
free(copy);
return (NULL);
}
*key = new_key;
*cp = '\0';
return (copy);
}
struct options_entry *
options_parse_get(struct options *oo, const char *s, char **key, int only)
{
struct options_entry *o;
char *name;
name = options_parse(s, key);
if (name == NULL)
return (NULL);
if (only)
o = options_get_only(oo, name);
else
o = options_get(oo, name);
free(name);
if (o == NULL) {
free(*key);
*key = NULL;
}
return (o);
}
const struct options_table_entry *
options_search(const char *name)
{
const struct options_table_entry *oe;
for (oe = options_table; oe->name != NULL; oe++) {
if (strcmp(oe->name, name) == 0)
return (oe);
}
return (NULL);
}
char *
options_match(const char *s, char **key, int *ambiguous)
{
const struct options_table_entry *oe, *found;
char *parsed;
const char *name;
size_t namelen;
parsed = options_parse(s, key);
if (parsed == NULL)
return (NULL);
if (*parsed == '@') {
*ambiguous = 0;
return (parsed);
}
name = options_map_name(parsed);
namelen = strlen(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(parsed);
free(*key);
*key = NULL;
return (NULL);
}
found = oe;
}
}
free(parsed);
if (found == NULL) {
*ambiguous = 0;
free(*key);
*key = NULL;
return (NULL);
}
return (xstrdup(found->name));
}
struct options_entry *
options_match_get(struct options *oo, const char *s, char **key, int only,
int *ambiguous)
{
char *name;
struct options_entry *o;
name = options_match(s, key, ambiguous);
if (name == NULL)
return (NULL);
*ambiguous = 0;
if (only)
o = options_get_only(oo, name);
else
o = options_get(oo, name);
free(name);
if (o == NULL) {
free(*key);
*key = NULL;
}
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->value.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->value.number);
}
struct cmd_list *
options_get_command(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_COMMAND(o))
fatalx("option %s is not a command", name);
return (o->value.cmdlist);
}
struct options_entry *
options_set_string(struct options *oo, const char *name, int append,
const char *fmt, ...)
{
struct options_entry *o;
va_list ap;
const char *separator = "";
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)) {
if (*name != '@') {
separator = o->tableentry->separator;
if (separator == NULL)
separator = "";
}
xasprintf(&value, "%s%s%s", o->value.string, separator, 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->value.string);
o->value.string = value;
o->cached = 0;
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->value.number = value;
return (o);
}
struct options_entry *
options_set_command(struct options *oo, const char *name,
struct cmd_list *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_COMMAND(o))
fatalx("option %s is not a command", name);
if (o->value.cmdlist != NULL)
cmd_list_free(o->value.cmdlist);
o->value.cmdlist = value;
return (o);
}
int
options_scope_from_name(struct args *args, int window,
const char *name, struct cmd_find_state *fs, struct options **oo,
char **cause)
{
struct session *s = fs->s;
struct winlink *wl = fs->wl;
struct window_pane *wp = fs->wp;
const char *target = args_get(args, 't');
const struct options_table_entry *oe;
int scope = OPTIONS_TABLE_NONE;
if (*name == '@')
return (options_scope_from_flags(args, window, fs, oo, cause));
for (oe = options_table; oe->name != NULL; oe++) {
if (strcmp(oe->name, name) == 0)
break;
}
if (oe->name == NULL) {
xasprintf(cause, "unknown option: %s", name);
return (OPTIONS_TABLE_NONE);
}
switch (oe->scope) {
case OPTIONS_TABLE_SERVER:
*oo = global_options;
scope = OPTIONS_TABLE_SERVER;
break;
case OPTIONS_TABLE_SESSION:
if (args_has(args, 'g')) {
*oo = global_s_options;
scope = OPTIONS_TABLE_SESSION;
} else if (s == NULL && target != NULL)
xasprintf(cause, "no such session: %s", target);
else if (s == NULL)
xasprintf(cause, "no current session");
else {
*oo = s->options;
scope = OPTIONS_TABLE_SESSION;
}
break;
case OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE:
if (args_has(args, 'p')) {
if (wp == NULL && target != NULL)
xasprintf(cause, "no such pane: %s", target);
else if (wp == NULL)
xasprintf(cause, "no current pane");
else {
*oo = wp->options;
scope = OPTIONS_TABLE_PANE;
}
break;
}
case OPTIONS_TABLE_WINDOW:
if (args_has(args, 'g')) {
*oo = global_w_options;
scope = OPTIONS_TABLE_WINDOW;
} else if (wl == NULL && target != NULL)
xasprintf(cause, "no such window: %s", target);
else if (wl == NULL)
xasprintf(cause, "no current window");
else {
*oo = wl->window->options;
scope = OPTIONS_TABLE_WINDOW;
}
break;
}
return (scope);
}
int
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;
struct window_pane *wp = fs->wp;
const char *target = args_get(args, 't');
if (args_has(args, 's')) {
*oo = global_options;
return (OPTIONS_TABLE_SERVER);
}
if (args_has(args, 'p')) {
if (wp == NULL) {
if (target != NULL)
xasprintf(cause, "no such pane: %s", target);
else
xasprintf(cause, "no current pane");
return (OPTIONS_TABLE_NONE);
}
*oo = wp->options;
return (OPTIONS_TABLE_PANE);
} else 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);
}
}
struct style *
options_string_to_style(struct options *oo, const char *name,
struct format_tree *ft)
{
struct options_entry *o;
const struct options_table_entry *oe;
const struct grid_cell *dgc = &grid_default_cell;
const char *s;
char *expanded;
int failed;
o = options_get(oo, name);
if (o == NULL || !OPTIONS_IS_STRING(o))
return (NULL);
if (o->cached)
return (&o->style);
s = o->value.string;
oe = o->tableentry;
log_debug("%s: %s is '%s'", __func__, name, s);
style_set(&o->style, dgc);
o->cached = (strstr(s, "#{") == NULL);
if (ft != NULL && !o->cached) {
expanded = format_expand(ft, s);
if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_COLOUR))
failed = style_parse_colour(&o->style, dgc, expanded);
else
failed = style_parse(&o->style, dgc, expanded);
free(expanded);
if (failed != 0)
return (NULL);
} else {
if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_COLOUR))
failed = style_parse_colour(&o->style, dgc, s);
else
failed = style_parse(&o->style, dgc, s);
if (failed != 0)
return (NULL);
}
return (&o->style);
}
static int
options_from_string_check(const struct options_table_entry *oe,
const char *value, char **cause)
{
struct style sy;
if (oe == NULL)
return (0);
if (strcmp(oe->name, "default-shell") == 0 && !checkshell(value)) {
xasprintf(cause, "not a suitable shell: %s", value);
return (-1);
}
if (oe->pattern != NULL && fnmatch(oe->pattern, value, 0) != 0) {
xasprintf(cause, "value is invalid: %s", value);
return (-1);
}
if ((oe->flags & OPTIONS_TABLE_IS_STYLE) &&
strstr(value, "#{") == NULL &&
style_parse(&sy, &grid_default_cell, value) != 0) {
xasprintf(cause, "invalid style: %s", value);
return (-1);
}
if ((oe->flags & OPTIONS_TABLE_IS_COLOUR) &&
strstr(value, "#{") == NULL &&
style_parse_colour(&sy, &grid_default_cell, value) != 0) {
xasprintf(cause, "invalid colour: %s", value);
return (-1);
}
return (0);
}
static int
options_from_string_flag(struct options *oo, const char *name,
const char *value, char **cause)
{
int flag;
if (value == NULL || *value == '\0')
flag = !options_get_number(oo, name);
else if (strcmp(value, "1") == 0 ||
strcasecmp(value, "on") == 0 ||
strcasecmp(value, "yes") == 0)
flag = 1;
else if (strcmp(value, "0") == 0 ||
strcasecmp(value, "off") == 0 ||
strcasecmp(value, "no") == 0)
flag = 0;
else {
xasprintf(cause, "bad value: %s", value);
return (-1);
}
options_set_number(oo, name, flag);
return (0);
}
int
options_find_choice(const struct options_table_entry *oe, const char *value,
char **cause)
{
const char **cp;
int n = 0, choice = -1;
for (cp = oe->choices; *cp != NULL; cp++) {
if (strcmp(*cp, value) == 0)
choice = n;
n++;
}
if (choice == -1) {
xasprintf(cause, "unknown value: %s", value);
return (-1);
}
return (choice);
}
static int
options_from_string_choice(const struct options_table_entry *oe,
struct options *oo, const char *name, const char *value, char **cause)
{
int choice = -1;
if (value == NULL) {
choice = options_get_number(oo, name);
if (choice < 2)
choice = !choice;
} else {
choice = options_find_choice(oe, value, cause);
if (choice < 0)
return (-1);
}
options_set_number(oo, name, choice);
return (0);
}
int
options_from_string(struct options *oo, const struct options_table_entry *oe,
const char *name, const char *value, int append, char **cause)
{
enum options_table_type type;
long long number;
const char *errstr, *new;
char *old;
key_code key;
struct cmd_parse_result *pr;
if (oe != NULL) {
if (value == NULL &&
oe->type != OPTIONS_TABLE_FLAG &&
oe->type != OPTIONS_TABLE_CHOICE) {
xasprintf(cause, "empty value");
return (-1);
}
type = oe->type;
} else {
if (*name != '@') {
xasprintf(cause, "bad option name");
return (-1);
}
type = OPTIONS_TABLE_STRING;
}
switch (type) {
case OPTIONS_TABLE_STRING:
old = xstrdup(options_get_string(oo, name));
options_set_string(oo, name, append, "%s", value);
new = options_get_string(oo, name);
if (options_from_string_check(oe, new, cause) != 0) {
options_set_string(oo, name, 0, "%s", old);
free(old);
return (-1);
}
free(old);
return (0);
case OPTIONS_TABLE_NUMBER:
number = strtonum(value, oe->minimum, oe->maximum, &errstr);
if (errstr != NULL) {
xasprintf(cause, "value is %s: %s", errstr, value);
return (-1);
}
options_set_number(oo, name, number);
return (0);
case OPTIONS_TABLE_KEY:
key = key_string_lookup_string(value);
if (key == KEYC_UNKNOWN) {
xasprintf(cause, "bad key: %s", value);
return (-1);
}
options_set_number(oo, name, key);
return (0);
case OPTIONS_TABLE_COLOUR:
if ((number = colour_fromstring(value)) == -1) {
xasprintf(cause, "bad colour: %s", value);
return (-1);
}
options_set_number(oo, name, number);
return (0);
case OPTIONS_TABLE_FLAG:
return (options_from_string_flag(oo, name, value, cause));
case OPTIONS_TABLE_CHOICE:
return (options_from_string_choice(oe, oo, name, value, cause));
case OPTIONS_TABLE_COMMAND:
pr = cmd_parse_from_string(value, NULL);
switch (pr->status) {
case CMD_PARSE_ERROR:
*cause = pr->error;
return (-1);
case CMD_PARSE_SUCCESS:
options_set_command(oo, name, pr->cmdlist);
return (0);
}
break;
}
return (-1);
}
void
options_push_changes(const char *name)
{
struct client *loop;
struct session *s;
struct window *w;
struct window_pane *wp;
log_debug("%s: %s", __func__, name);
if (strcmp(name, "theme") == 0 ||
strncmp(name, "dark-theme-", 11) == 0 ||
strncmp(name, "light-theme-", 12) == 0) {
TAILQ_FOREACH(loop, &clients, entry) {
server_client_update_theme_colours(loop);
if (loop->tty.flags & TTY_OPENED)
tty_invalidate(&loop->tty);
server_redraw_client(loop);
}
}
if (strcmp(name, "automatic-rename") == 0) {
RB_FOREACH(w, windows, &windows) {
if (w->active == NULL)
continue;
if (options_get_number(w->options, name))
w->active->flags |= PANE_CHANGED;
}
}
if (strcmp(name, "cursor-colour") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
window_pane_default_cursor(wp);
}
if (strcmp(name, "cursor-style") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
window_pane_default_cursor(wp);
}
if (strcmp(name, "fill-character") == 0) {
RB_FOREACH(w, windows, &windows)
window_set_fill_cells(w);
}
if (strcmp(name, "key-table") == 0) {
TAILQ_FOREACH(loop, &clients, entry)
server_client_set_key_table(loop, NULL);
}
if (strcmp(name, "user-keys") == 0) {
TAILQ_FOREACH(loop, &clients, entry) {
if (loop->tty.flags & TTY_OPENED)
tty_keys_build(&loop->tty);
}
}
if (strcmp(name, "status") == 0 ||
strcmp(name, "status-interval") == 0)
status_timer_start_all();
if (strcmp(name, "status") == 0 ||
strcmp(name, "status-position") == 0 ||
strcmp(name, "pane-border-indicators") == 0 ||
strcmp(name, "pane-border-lines") == 0 ||
strcmp(name, "pane-border-status") == 0 ||
strcmp(name, "pane-scrollbars") == 0 ||
strcmp(name, "pane-scrollbars-timeout") == 0 ||
strcmp(name, "pane-scrollbars-position") == 0 ||
strcmp(name, "pane-scrollbars-style") == 0)
redraw_invalidate_all_scenes();
if (strcmp(name, "monitor-silence") == 0)
alerts_reset_all();
if (strcmp(name, "window-style") == 0 ||
strcmp(name, "window-active-style") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
}
if (*name == '@') {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
wp->flags |= PANE_STYLECHANGED;
}
if (strcmp(name, "pane-colours") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
colour_palette_from_option(&wp->palette, wp->options);
}
if (strcmp(name, "pane-border-status") == 0 ||
strcmp(name, "pane-scrollbars") == 0 ||
strcmp(name, "pane-scrollbars-position") == 0) {
RB_FOREACH(w, windows, &windows) {
w->sb = options_get_number(w->options,
"pane-scrollbars");
w->sb_pos = options_get_number(w->options,
"pane-scrollbars-position");
layout_fix_panes(w, NULL);
}
}
if (strcmp(name, "pane-scrollbars") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes)
window_pane_scrollbar_hide(wp);
}
if (strcmp(name, "pane-scrollbars-style") == 0) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
style_set_scrollbar_style_from_option(
&wp->scrollbar_style, wp->options);
}
RB_FOREACH(w, windows, &windows)
layout_fix_panes(w, NULL);
}
if (strcmp(name, "codepoint-widths") == 0)
utf8_update_width_cache();
if (strcmp(name, "input-buffer-size") == 0)
input_set_buffer_size(options_get_number(global_options, name));
if (strcmp(name, "history-limit") == 0) {
RB_FOREACH(s, sessions, &sessions)
session_update_history(s);
}
RB_FOREACH(s, sessions, &sessions)
status_update_cache(s);
recalculate_sizes();
TAILQ_FOREACH(loop, &clients, entry) {
if (loop->session != NULL)
server_redraw_client(loop);
}
}
int
options_remove_or_default(struct options_entry *o, const char *key,
char **cause)
{
struct options *oo = o->owner;
if (key == NULL) {
if (o->tableentry != NULL &&
(oo == global_options ||
oo == global_s_options ||
oo == global_w_options))
options_default(oo, o->tableentry);
else
options_remove(o);
} else if (options_array_set(o, key, NULL, 0, cause) != 0)
return (-1);
return (0);
}
