1
0
mirror of https://github.com/rkd77/elinks.git synced 2024-10-09 05:20:36 -04:00
elinks/src/config/options.c
2016-04-20 22:21:31 +02:00

1356 lines
36 KiB
C

/* Options variables manipulation core */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <string.h>
#include "elinks.h"
#include "bfu/dialog.h"
#include "cache/cache.h"
#include "config/conf.h"
#include "config/dialogs.h"
#include "config/domain.h"
#include "config/options.h"
#include "config/opttypes.h"
#include "dialogs/status.h"
#include "document/document.h"
#include "globhist/globhist.h"
#include "intl/charsets.h"
#include "intl/gettext/libintl.h"
#include "main/main.h" /* shrink_memory() */
#include "main/select.h"
#include "network/connection.h"
#include "session/session.h"
#include "terminal/color.h"
#include "terminal/screen.h"
#include "terminal/terminal.h"
#include "util/color.h"
#include "util/error.h"
#include "util/memory.h"
#include "util/string.h"
#include "viewer/text/draw.h"
/* TODO? In the past, covered by shadow and legends, remembered only by the
* ELinks Elders now, options were in hashes (it was not for a long time, after
* we started to use dynamic options lists and before we really started to use
* hierarchic options). Hashes might be swift and deft, but they had a flaw and
* the flaw showed up as the fatal flaw. They were unsorted, and it was
* unfriendly to mere mortal users, without pasky's options handlers in their
* brain, but their own poor-written software. And thus pasky went and rewrote
* options so that they were in lists from then to now and for all the ages of
* men, to the glory of mankind. However, one true hero may arise in future
* fabulous and implement possibility to have both lists and hashes for trees,
* as it may be useful for some supernatural entities. And when that age will
* come... */
/* TODO: We should remove special case for root options and use some auxiliary
* (struct option *) instead. This applies to bookmarks, global history and
* listbox items as well, though. --pasky */
static INIT_LIST_OF(struct option, options_root_tree);
static struct option options_root = INIT_OPTION(
/* name: */ "",
/* flags: */ 0,
/* type: */ OPT_TREE,
/* min, max: */ 0, 0,
/* value: */ &options_root_tree,
/* desc: */ "",
/* capt: */ NULL
);
struct option *config_options;
struct option *cmdline_options;
static void add_opt_rec(struct option *, unsigned char *, struct option *);
static void free_options_tree(LIST_OF(struct option) *, int recursive);
#ifdef CONFIG_DEBUG
/* Detect ending '.' (and some others) in options captions.
* It will emit a message in debug mode only. --Zas */
#define bad_punct(c) (c != ')' && c != '>' && !isquote(c) && ispunct(c))
static void
check_caption(unsigned char *caption)
{
int len;
unsigned char c;
if (!caption) return;
len = strlen(caption);
if (!len) return;
c = caption[len - 1];
if (isspace(c) || bad_punct(c))
DBG("bad char at end of caption [%s]", caption);
#ifdef CONFIG_NLS
caption = gettext(caption);
len = strlen(caption);
if (!len) return;
c = caption[len - 1];
if (isspace(c) || bad_punct(c))
DBG("bad char at end of i18n caption [%s]", caption);
#endif
}
#undef bad_punct
static void
check_description(unsigned char *desc)
{
int len;
unsigned char c;
if (!desc) return;
len = strlen(desc);
if (!len) return;
c = desc[len - 1];
if (isspace(c))
DBG("bad char at end of description [%s]", desc);
#ifdef CONFIG_NLS
desc = gettext(desc);
len = strlen(desc);
if (!len) return;
if (ispunct(c) != ispunct(desc[len - 1]))
DBG("punctuation char possibly missing at end of i18n description [%s]", desc);
c = desc[len - 1];
if (isspace(c))
DBG("bad char at end of i18n description [%s]", desc);
#endif
}
/*! @relates option */
static void
debug_check_option_syntax(struct option *option)
{
if (!option) return;
check_caption(option->capt);
check_description(option->desc);
}
#else
#define debug_check_option_syntax(option)
#endif
/**********************************************************************
Options interface
**********************************************************************/
/* If option name contains dots, they are created as "categories" - first,
* first category is retrieved from list, taken as a list, second category
* is retrieved etc. */
/* Ugly kludge */
static int no_autocreate = 0;
/** Get record of option of given name, or NULL if there's no such option.
*
* If the specified option is an ::OPT_ALIAS, this function returns the
* alias, rather than the option to which the alias refers. It must
* work this way because the alias may have the ::OPT_ALIAS_NEGATE flag.
* Instead, if the caller tries to read or set the value of the alias,
* the functions associated with ::OPT_ALIAS will forward the operation
* to the underlying option. However, see indirect_option().
*
* @relates option */
struct option *
get_opt_rec(struct option *tree, const unsigned char *name_)
{
struct option *option;
unsigned char *aname = stracpy(name_);
unsigned char *name = aname;
unsigned char *sep;
if (!aname) return NULL;
/* We iteratively call get_opt_rec() each for path_elements-1, getting
* appropriate tree for it and then resolving [path_elements]. */
if ((sep = strrchr((const char *)name, '.'))) {
*sep = '\0';
tree = get_opt_rec(tree, name);
if (!tree || tree->type != OPT_TREE || tree->flags & OPT_HIDDEN) {
#if 0
DBG("ERROR in get_opt_rec() crawl: %s (%d) -> %s",
name, tree ? tree->type : -1, sep + 1);
#endif
mem_free(aname);
return NULL;
}
*sep = '.';
name = sep + 1;
}
foreach (option, *tree->value.tree) {
if (option->name && !strcmp(option->name, name)) {
mem_free(aname);
return option;
}
}
if (tree && tree->flags & OPT_AUTOCREATE && !no_autocreate) {
struct option *template_ = get_opt_rec(tree, "_template_");
assertm(template_ != NULL, "Requested %s should be autocreated but "
"%.*s._template_ is missing!", name_, sep - name_,
name_);
if_assert_failed {
mem_free(aname);
return NULL;
}
/* We will just create the option and return pointer to it
* automagically. And, we will create it by cloning _template_
* option. By having _template_ OPT_AUTOCREATE and _template_
* inside, you can have even multi-level autocreating. */
option = copy_option(template_, 0);
if (!option) {
mem_free(aname);
return NULL;
}
mem_free_set(&option->name, stracpy(name));
add_opt_rec(tree, "", option);
mem_free(aname);
return option;
}
mem_free(aname);
return NULL;
}
/** Get record of option of given name, or NULL if there's no such option. But
* do not create the option if it doesn't exist and there's autocreation
* enabled.
* @relates option */
struct option *
get_opt_rec_real(struct option *tree, const unsigned char *name)
{
struct option *opt;
no_autocreate = 1;
opt = get_opt_rec(tree, name);
no_autocreate = 0;
return opt;
}
/** If @a opt is an alias, return the option to which it refers.
*
* @warning Because the alias may have the ::OPT_ALIAS_NEGATE flag,
* the caller must not access the value of the returned option as if
* it were also the value of the alias. However, it is safe to access
* flags such as ::OPT_MUST_SAVE and ::OPT_DELETED.
*
* @relates option */
struct option *
indirect_option(struct option *alias)
{
struct option *real;
if (alias->type != OPT_ALIAS) return alias; /* not an error */
real = get_opt_rec(config_options, alias->value.string);
assertm(real != NULL, "%s aliased to unknown option %s!",
alias->name, alias->value.string);
if_assert_failed return alias;
return real;
}
/** Fetch pointer to value of certain option. It is guaranteed to never return
* NULL. Note that you are supposed to use wrapper get_opt().
* @relates option */
union option_value *
get_opt_(
#ifdef CONFIG_DEBUG
unsigned char *file, int line, enum option_type option_type,
#endif
struct option *tree, unsigned char *name, struct session *ses)
{
struct option *opt = NULL;
/* If given a session and the option is shadowed in that session's
* options tree, return the shadow. */
if (ses && ses->option)
opt = get_opt_rec_real(ses->option, name);
/* If given a session, no session-specific option was found, and the
* option has a shadow in the domain tree that matches the current
* document in that session, return that shadow. */
if (!opt && ses)
opt = get_domain_option_from_session(name, ses);
/* Else, return the real option. */
if (!opt)
opt = get_opt_rec(tree, name);
#ifdef CONFIG_DEBUG
errfile = file;
errline = line;
if (!opt) elinks_internal("Attempted to fetch nonexisting option %s!", name);
/* Various sanity checks. */
if (option_type != opt->type)
DBG("get_opt_*(\"%s\") @ %s:%d: call with wrapper for %s for option of type %s",
name, file, line,
get_option_type_name(option_type),
get_option_type_name(opt->type));
switch (opt->type) {
case OPT_TREE:
if (!opt->value.tree)
elinks_internal("Option %s has no value!", name);
break;
case OPT_ALIAS:
elinks_internal("Invalid use of alias %s for option %s!",
name, opt->value.string);
break;
case OPT_STRING:
if (!opt->value.string)
elinks_internal("Option %s has no value!", name);
break;
case OPT_BOOL:
case OPT_INT:
if (opt->value.number < opt->min
|| opt->value.number > opt->max)
elinks_internal("Option %s has invalid value %d!", name, opt->value.number);
break;
case OPT_LONG:
if (opt->value.big_number < opt->min
|| opt->value.big_number > opt->max)
elinks_internal("Option %s has invalid value %ld!", name, opt->value.big_number);
break;
case OPT_COMMAND:
if (!opt->value.command)
elinks_internal("Option %s has no value!", name);
break;
case OPT_CODEPAGE: /* TODO: check these too. */
case OPT_LANGUAGE:
case OPT_COLOR:
break;
}
#endif
return &opt->value;
}
/*! @relates option */
static void
add_opt_sort(struct option *tree, struct option *option, int abi)
{
LIST_OF(struct option) *cat = tree->value.tree;
LIST_OF(struct listbox_item) *bcat = &tree->box_item->child;
struct option *pos;
/* The list is empty, just add it there. */
if (list_empty(*cat)) {
add_to_list(*cat, option);
if (abi) add_to_list(*bcat, option->box_item);
/* This fits as the last list entry, add it there. This
* optimizes the most expensive BUT most common case ;-). */
} else if ((option->type != OPT_TREE
|| ((struct option *) cat->prev)->type == OPT_TREE)
&& strcmp(((struct option *) cat->prev)->name,
option->name) <= 0) {
append:
add_to_list_end(*cat, option);
if (abi) add_to_list_end(*bcat, option->box_item);
/* At the end of the list is tree and we are ordinary. That's
* clear case then. */
} else if (option->type != OPT_TREE
&& ((struct option *) cat->prev)->type == OPT_TREE) {
goto append;
/* Scan the list linearly. This could be probably optimized ie.
* to choose direction based on the first letter or so. */
} else {
struct listbox_item *bpos = (struct listbox_item *) bcat;
foreach (pos, *cat) {
/* First move the box item to the current position but
* only if the position has not been marked as deleted
* and actually has a box_item -- else we will end up
* 'overflowing' and causing assertion failure. */
if (!(pos->flags & OPT_DELETED) && pos->box_item) {
bpos = bpos->next;
assert(bpos != (struct listbox_item *) bcat);
}
if ((option->type != OPT_TREE
|| pos->type == OPT_TREE)
&& strcmp(pos->name, option->name) <= 0)
continue;
/* Ordinary options always sort behind trees. */
if (option->type != OPT_TREE
&& pos->type == OPT_TREE)
continue;
/* The (struct option) add_at_pos() can mess up the
* order so that we add the box_item to itself, so
* better do it first. */
/* Always ensure that them _template_ options are
* before anything else so a lonely autocreated option
* (with _template_ options set to invisible) will be
* connected with an upper corner (ascii: `-) instead
* of a rotated T (ascii: +-) when displaying it. */
if (option->type == pos->type
&& *option->name <= '_'
&& !strcmp(pos->name, "_template_")) {
if (abi) add_at_pos(bpos, option->box_item);
add_at_pos(pos, option);
break;
}
if (abi) add_at_pos(bpos->prev, option->box_item);
add_at_pos(pos->prev, option);
break;
}
assert(pos != (struct option *) cat);
assert(bpos != (struct listbox_item *) bcat);
}
}
/** Add option to tree.
* @relates option */
static void
add_opt_rec(struct option *tree, unsigned char *path, struct option *option)
{
int abi = 0;
assert(path && option && tree);
if (*path) tree = get_opt_rec(tree, path);
assertm(tree != NULL, "Missing option tree for '%s'", path);
if (!tree->value.tree) return;
object_nolock(option, "option");
if (option->box_item && option->name && !strcmp(option->name, "_template_"))
option->box_item->visible = get_opt_bool("config.show_template", NULL);
if (tree->flags & OPT_AUTOCREATE && !option->desc) {
struct option *template_ = get_opt_rec(tree, "_template_");
assert(template_);
option->desc = template_->desc;
}
option->root = tree;
abi = (tree->box_item && option->box_item);
if (abi) {
/* The config_root tree is a just a placeholder for the
* box_items, it actually isn't a real box_item by itself;
* these ghosts are indicated by the fact that they have
* NULL @next. */
if (tree->box_item->next) {
option->box_item->depth = tree->box_item->depth + 1;
}
}
if (tree->flags & OPT_SORT) {
add_opt_sort(tree, option, abi);
} else {
add_to_list_end(*tree->value.tree, option);
if (abi) add_to_list_end(tree->box_item->child, option->box_item);
}
update_hierbox_browser(&option_browser);
}
/*! @relates option */
static inline struct listbox_item *
init_option_listbox_item(struct option *option)
{
struct listbox_item *item = mem_calloc(1, sizeof(*item));
if (!item) return NULL;
init_list(item->child);
item->visible = 1;
item->udata = option;
item->type = (option->type == OPT_TREE) ? BI_FOLDER : BI_LEAF;
return item;
}
/*! @relates option */
struct option *
add_opt(struct option *tree, unsigned char *path, unsigned char *capt,
unsigned char *name, enum option_flags flags, enum option_type type,
long min, long max, longptr_T value, unsigned char *desc)
{
struct option *option = mem_calloc(1, sizeof(*option));
if (!option) return NULL;
option->name = stracpy(name);
if (!option->name) {
mem_free(option);
return NULL;
}
option->flags = (flags | OPT_ALLOC);
option->type = type;
option->min = min;
option->max = max;
option->capt = capt;
option->desc = desc;
debug_check_option_syntax(option);
/* XXX: For allocated values we allocate in the add_opt_<type>() macro.
* This involves OPT_TREE and OPT_STRING. */
switch (type) {
case OPT_TREE:
if (!value) {
mem_free(option);
return NULL;
}
option->value.tree = (LIST_OF(struct option) *) value;
break;
case OPT_STRING:
if (!value) {
mem_free(option);
return NULL;
}
option->value.string = (unsigned char *) value;
break;
case OPT_ALIAS:
option->value.string = (unsigned char *) value;
break;
case OPT_BOOL:
case OPT_INT:
case OPT_CODEPAGE:
option->value.number = (int) value;
break;
case OPT_LONG:
option->value.big_number = (long) value; /* FIXME: cast from void * */
break;
case OPT_COLOR:
decode_color((unsigned char *) value, strlen((unsigned char *) value),
&option->value.color);
break;
case OPT_COMMAND:
option->value.command = (void *) value;
break;
case OPT_LANGUAGE:
break;
}
if (option->type != OPT_ALIAS
&& ((tree->flags & OPT_LISTBOX) || (option->flags & OPT_LISTBOX))) {
option->box_item = init_option_listbox_item(option);
if (!option->box_item) {
mem_free(option);
return NULL;
}
}
add_opt_rec(tree, path, option);
return option;
}
/*! @relates option */
static void
done_option(struct option *option)
{
switch (option->type) {
case OPT_STRING:
mem_free_if(option->value.string);
break;
case OPT_TREE:
mem_free_if(option->value.tree);
break;
default:
break;
}
if (option->box_item)
done_listbox_item(&option_browser, option->box_item);
if (option->flags & OPT_ALLOC) {
mem_free_if(option->name);
mem_free(option);
} else if (!option->capt) {
/* We are probably dealing with a built-in autocreated option
* that will be attempted to be deleted when shutting down. */
/* Clear it so nothing will be done later. */
memset(option, 0, sizeof(*option));
}
}
/* The namespace may start to seem a bit chaotic here; it indeed is, maybe the
* function names above should be renamed and only macros should keep their old
* short names. */
/* The simple rule I took as an apologize is that functions which take already
* completely filled (struct option *) have long name and functions which take
* only option specs have short name. */
/*! @relates option */
static void
delete_option_do(struct option *option, int recursive)
{
if (option->next) {
del_from_list(option);
option->prev = option->next = NULL;
}
if (recursive == -1) {
ERROR("Orphaned option %s", option->name);
}
if (option->type == OPT_TREE && option->value.tree
&& !list_empty(*option->value.tree)) {
if (!recursive) {
if (option->flags & OPT_AUTOCREATE) {
recursive = 1;
} else {
ERROR("Orphaned unregistered "
"option in subtree %s!",
option->name);
recursive = -1;
}
}
free_options_tree(option->value.tree, recursive);
}
done_option(option);
}
/*! @relates option */
void
mark_option_as_deleted(struct option *option)
{
if (option->type == OPT_TREE) {
struct option *unmarked;
assert(option->value.tree);
foreach (unmarked, *option->value.tree)
mark_option_as_deleted(unmarked);
}
option->box_item->visible = 0;
option->flags |= (OPT_TOUCHED | OPT_DELETED);
}
/*! @relates option */
void
delete_option(struct option *option)
{
delete_option_do(option, 1);
}
/*! @relates option */
struct option *
copy_option(struct option *template_, int flags)
{
struct option *option = mem_calloc(1, sizeof(*option));
if (!option) return NULL;
option->name = null_or_stracpy(template_->name);
option->flags = (template_->flags | OPT_ALLOC);
option->type = template_->type;
option->min = template_->min;
option->max = template_->max;
option->capt = template_->capt;
option->desc = template_->desc;
option->change_hook = template_->change_hook;
if (!(flags & CO_NO_LISTBOX_ITEM))
option->box_item = init_option_listbox_item(option);
if (option->box_item) {
if (template_->box_item) {
option->box_item->type = template_->box_item->type;
option->box_item->depth = template_->box_item->depth;
}
}
if (option_types[template_->type].dup) {
option_types[template_->type].dup(option, template_, flags);
} else {
option->value = template_->value;
}
return option;
}
/** Return the shadow option in @a shadow_tree of @a option in @a tree.
* If @a option isn't yet shadowed in @a shadow_tree, shadow it
* (i.e. create a copy in @a shadow_tree) along with any ancestors
* that aren't shadowed. */
struct option *
get_option_shadow(struct option *option, struct option *tree,
struct option *shadow_tree)
{
struct option *shadow_option = NULL;
assert(option);
assert(tree);
assert(shadow_tree);
if (option == tree) {
shadow_option = shadow_tree;
} else if (option->root && option->name) {
struct option *shadow_root;
shadow_root = get_option_shadow(option->root, tree,
shadow_tree);
if (!shadow_root) return NULL;
shadow_option = get_opt_rec_real(shadow_root, option->name);
if (!shadow_option) {
shadow_option = copy_option(option,
CO_SHALLOW
| CO_NO_LISTBOX_ITEM);
if (shadow_option) {
shadow_option->root = shadow_root;
/* No need to sort, is there? It isn't shown
* in the options manager. -- Miciah */
add_to_list_end(*shadow_root->value.tree,
shadow_option);
shadow_option->flags |= OPT_TOUCHED;
}
}
}
return shadow_option;
}
/*! @relates option */
LIST_OF(struct option) *
init_options_tree(void)
{
LIST_OF(struct option) *ptr = mem_alloc(sizeof(*ptr));
if (ptr) init_list(*ptr);
return ptr;
}
/** Some default pre-autocreated options. Doh. */
static inline void
register_autocreated_options(void)
{
/* TODO: Use table-driven initialization. --jonas */
get_opt_int("terminal.linux.type", NULL) = TERM_LINUX;
get_opt_int("terminal.linux.colors", NULL) = COLOR_MODE_16;
get_opt_bool("terminal.linux.m11_hack", NULL) = 1;
get_opt_int("terminal.vt100.type", NULL) = TERM_VT100;
get_opt_int("terminal.vt110.type", NULL) = TERM_VT100;
get_opt_int("terminal.xterm.type", NULL) = TERM_VT100;
get_opt_bool("terminal.xterm.underline", NULL) = 1;
get_opt_int("terminal.xterm-color.type", NULL) = TERM_VT100;
get_opt_int("terminal.xterm-color.colors", NULL) = COLOR_MODE_16;
get_opt_bool("terminal.xterm-color.underline", NULL) = 1;
#ifdef CONFIG_88_COLORS
get_opt_int("terminal.xterm-88color.type", NULL) = TERM_VT100;
get_opt_int("terminal.xterm-88color.colors", NULL) = COLOR_MODE_88;
get_opt_bool("terminal.xterm-88color.underline", NULL) = 1;
#endif
get_opt_int("terminal.rxvt-unicode.type", NULL) = 1;
#ifdef CONFIG_88_COLORS
get_opt_int("terminal.rxvt-unicode.colors", NULL) = COLOR_MODE_88;
#else
get_opt_int("terminal.rxvt-unicode.colors", NULL) = COLOR_MODE_16;
#endif
get_opt_bool("terminal.rxvt-unicode.italic", NULL) = 1;
get_opt_bool("terminal.rxvt-unicode.underline", NULL) = 1;
#ifdef CONFIG_256_COLORS
get_opt_int("terminal.xterm-256color.type", NULL) = TERM_VT100;
get_opt_int("terminal.xterm-256color.colors", NULL) = COLOR_MODE_256;
get_opt_bool("terminal.xterm-256color.underline", NULL) = 1;
get_opt_int("terminal.fbterm.type", NULL) = TERM_FBTERM;
get_opt_int("terminal.fbterm.colors", NULL) = COLOR_MODE_256;
get_opt_bool("terminal.fbterm.underline", NULL) = 0;
#endif
}
extern union option_info cmdline_options_info[];
#include "config/options.inc"
static int
change_hook_cache(struct session *ses, struct option *current, struct option *changed)
{
shrink_memory(0);
return 0;
}
static int
change_hook_connection(struct session *ses, struct option *current, struct option *changed)
{
register_check_queue();
return 0;
}
static int
change_hook_html(struct session *ses, struct option *current, struct option *changed)
{
foreach (ses, sessions) ses->tab->resize = 1;
return 0;
}
static int
change_hook_insert_mode(struct session *ses, struct option *current, struct option *changed)
{
update_status();
return 0;
}
static int
change_hook_active_link(struct session *ses, struct option *current, struct option *changed)
{
update_cached_document_options(ses);
return 0;
}
static int
change_hook_terminal(struct session *ses, struct option *current, struct option *changed)
{
cls_redraw_all_terminals();
return 0;
}
static int
change_hook_ui(struct session *ses, struct option *current, struct option *changed)
{
update_status();
return 0;
}
/** Make option templates visible or invisible in the option manager.
* This is called once on startup, and then each time the value of the
* "config.show_template" option is changed.
*
* @param tree
* The option tree whose children should be affected.
*
* @param show
* A set of bits:
* - The 0x01 bit means templates should be made visible.
* If the bit is clear, templates become invisible instead.
* - The 0x02 bit means @a tree is itself part of a template,
* and so all of its children should be affected, regardless
* of whether they are templates of their own.
*
* Deleted options are never visible.
*
* @relates option */
static void
update_visibility(LIST_OF(struct option) *tree, int show)
{
struct option *opt;
foreach (opt, *tree) {
if (opt->flags & OPT_DELETED) continue;
if (!strcmp(opt->name, "_template_")) {
if (opt->box_item)
opt->box_item->visible = (show & 1);
if (opt->type == OPT_TREE)
update_visibility(opt->value.tree, show | 2);
} else {
if (opt->box_item && (show & 2))
opt->box_item->visible = (show & 1);
if (opt->type == OPT_TREE)
update_visibility(opt->value.tree, show);
}
}
}
static int
change_hook_stemplate(struct session *ses, struct option *current, struct option *changed)
{
update_visibility(config_options->value.tree, changed->value.number);
return 0;
}
static int
change_hook_language(struct session *ses, struct option *current, struct option *changed)
{
#ifdef CONFIG_NLS
set_language(changed->value.number);
#endif
return 0;
}
static const struct change_hook_info change_hooks[] = {
{ "config.show_template", change_hook_stemplate },
{ "connection", change_hook_connection },
{ "document.browse", change_hook_html },
{ "document.browse.forms.insert_mode",
change_hook_insert_mode },
{ "document.browse.links.active_link",
change_hook_active_link },
{ "document.cache", change_hook_cache },
{ "document.codepage", change_hook_html },
{ "document.colors", change_hook_html },
{ "document.html", change_hook_html },
{ "document.plain", change_hook_html },
{ "terminal", change_hook_terminal },
{ "ui.language", change_hook_language },
{ "ui", change_hook_ui },
{ NULL, NULL },
};
void
init_options(void)
{
cmdline_options = add_opt_tree_tree(&options_root, "", "",
"cmdline", 0, "");
register_options(cmdline_options_info, cmdline_options);
config_options = add_opt_tree_tree(&options_root, "", "",
"config", OPT_SORT, "");
config_options->flags |= OPT_LISTBOX;
config_options->box_item = &option_browser.root;
register_options(config_options_info, config_options);
register_autocreated_options();
register_change_hooks(change_hooks);
}
/*! @relates option */
static void
free_options_tree(LIST_OF(struct option) *tree, int recursive)
{
while (!list_empty(*tree))
delete_option_do(tree->next, recursive);
}
void
done_options(void)
{
done_domain_trees();
unregister_options(config_options_info, config_options);
unregister_options(cmdline_options_info, cmdline_options);
config_options->box_item = NULL;
free_options_tree(&options_root_tree, 0);
}
/*! @relates change_hook_info */
void
register_change_hooks(const struct change_hook_info *change_hooks)
{
int i;
for (i = 0; change_hooks[i].name; i++) {
struct option *option = get_opt_rec(config_options,
change_hooks[i].name);
assert(option);
option->change_hook = change_hooks[i].change_hook;
}
}
/** Set or clear the ::OPT_MUST_SAVE flag in all descendants of @a tree.
*
* @param tree
* The option tree in which this function recursively sets or clears
* the flag.
*
* @param set_all
* If true, set ::OPT_MUST_SAVE in all options of the tree.
* If false, set it only in touched or deleted options, and clear in others.
*
* @relates option */
void
prepare_mustsave_flags(LIST_OF(struct option) *tree, int set_all)
{
struct option *option;
foreach (option, *tree) {
/* XXX: OPT_LANGUAGE shouldn't have any bussiness
* here, but we're just weird in that area. */
if (set_all
|| (option->flags & (OPT_TOUCHED | OPT_DELETED))
|| option->type == OPT_LANGUAGE)
option->flags |= OPT_MUST_SAVE;
else
option->flags &= ~OPT_MUST_SAVE;
if (option->type == OPT_TREE)
prepare_mustsave_flags(option->value.tree, set_all);
}
}
/** Clear the ::OPT_TOUCHED flag in all descendants of @a tree.
* @relates option */
void
untouch_options(LIST_OF(struct option) *tree)
{
struct option *option;
foreach (option, *tree) {
option->flags &= ~OPT_TOUCHED;
if (option->type == OPT_TREE)
untouch_options(option->value.tree);
}
}
/*! @relates option */
static int
check_nonempty_tree(LIST_OF(struct option) *options)
{
struct option *opt;
foreach (opt, *options) {
if (opt->type == OPT_TREE) {
if (check_nonempty_tree(opt->value.tree))
return 1;
} else if (opt->flags & OPT_MUST_SAVE) {
return 1;
}
}
return 0;
}
/*! @relates option */
void
smart_config_string(struct string *str, int print_comment, int i18n,
LIST_OF(struct option) *options,
unsigned char *path, int depth,
void (*fn)(struct string *, struct option *,
unsigned char *, int, int, int, int))
{
struct option *option;
foreach (option, *options) {
int do_print_comment = 1;
if (option->flags & OPT_HIDDEN ||
option->type == OPT_ALIAS ||
!strcmp(option->name, "_template_"))
continue;
/* Is there anything to be printed anyway? */
if (option->type == OPT_TREE
? !check_nonempty_tree(option->value.tree)
: !(option->flags & OPT_MUST_SAVE))
continue;
/* We won't pop out the description when we're in autocreate
* category and not template. It'd be boring flood of
* repetitive comments otherwise ;). */
/* This print_comment parameter is weird. If it is negative, it
* means that we shouldn't print comments at all. If it is 1,
* we shouldn't print comment UNLESS the option is _template_
* or not-an-autocreating-tree (it is set for the first-level
* autocreation tree). When it is 2, we can print out comments
* normally. */
/* It is still broken somehow, as it didn't work for terminal.*
* (the first autocreated level) by the time I wrote this. Good
* summer job for bored mad hackers with spare boolean mental
* power. I have better things to think about, personally.
* Maybe we should just mark autocreated options somehow ;). */
if (!print_comment || (print_comment == 1
&& (strcmp(option->name, "_template_")
&& (option->flags & OPT_AUTOCREATE
&& option->type == OPT_TREE))))
do_print_comment = 0;
/* Pop out the comment */
/* For config file, we ignore do_print_comment everywhere
* except 1, but sometimes we want to skip the option totally.
*/
fn(str, option, path, depth,
option->type == OPT_TREE ? print_comment
: do_print_comment,
0, i18n);
fn(str, option, path, depth, do_print_comment, 1, i18n);
/* And the option itself */
if (option_types[option->type].write) {
fn(str, option, path, depth,
do_print_comment, 2, i18n);
} else if (option->type == OPT_TREE) {
struct string newpath;
int pc = print_comment;
if (!init_string(&newpath)) continue; /* OK? */
if (pc == 2 && option->flags & OPT_AUTOCREATE)
pc = 1;
else if (pc == 1 && strcmp(option->name, "_template_"))
pc = 0;
fn(str, option, path, depth, /*pc*/1, 3, i18n);
if (path) {
add_to_string(&newpath, path);
add_char_to_string(&newpath, '.');
}
add_to_string(&newpath, option->name);
smart_config_string(str, pc, i18n, option->value.tree,
newpath.source, depth + 1, fn);
done_string(&newpath);
fn(str, option, path, depth, /*pc*/1, 3, i18n);
}
}
}
void
update_options_visibility(void)
{
update_visibility(config_options->value.tree,
get_opt_bool("config.show_template", NULL));
}
void
toggle_option(struct session *ses, struct option *option)
{
long number = option->value.number + 1;
assert(option->type == OPT_BOOL || option->type == OPT_INT);
assert(option->max);
option->value.number = (number <= option->max) ? number : option->min;
option_changed(ses, option);
}
void
call_change_hooks(struct session *ses, struct option *current, struct option *option)
{
/* This boolean thing can look a little weird - it
* basically says that we should proceed when there's
* no change_hook or there's one and its return value
* was zero. */
while (current && (!current->change_hook ||
!current->change_hook(ses, current, option))) {
if (!current->root)
break;
current = current->root;
}
}
void
option_changed(struct session *ses, struct option *option)
{
option->flags |= OPT_TOUCHED;
/* Notify everyone out there! */
call_change_hooks(ses, option, option);
}
/*! @relates option_resolver */
int
commit_option_values(struct option_resolver *resolvers,
struct option *root, union option_value *values, int size)
{
int touched = 0;
int i;
assert(resolvers && root && values && size);
for (i = 0; i < size; i++) {
unsigned char *name = resolvers[i].name;
struct option *option = get_opt_rec(root, name);
int id = resolvers[i].id;
assertm(option, "Bad option '%s' in options resolver", name);
if (memcmp(&option->value, &values[id], sizeof(union option_value))) {
option->value = values[id];
option->flags |= OPT_TOUCHED;
/* Speed hack: Directly call the change-hook for each
* option in resolvers and later call call_change_hooks
* on the root; if we were to call call_change_hooks
* on each option in resolvers, we would end up calling
* the change-hooks of root, its parents, its
* grandparents, and so on for each option in resolvers
* because call_change_hooks is recursive. -- Miciah */
if (option->change_hook)
option->change_hook(NULL, option, NULL);
touched++;
}
}
/* See above 'Speed hack' comment. */
call_change_hooks(NULL, root, NULL);
return touched;
}
/*! @relates option_resolver */
void
checkout_option_values(struct option_resolver *resolvers,
struct option *root,
union option_value *values, int size)
{
int i;
for (i = 0; i < size; i++) {
unsigned char *name = resolvers[i].name;
struct option *option = get_opt_rec(root, name);
int id = resolvers[i].id;
assertm(option, "Bad option '%s' in options resolver", name);
values[id] = option->value;
}
}
/**********************************************************************
Options values
**********************************************************************/
/*! @relates option_info */
void
register_options(union option_info info[], struct option *tree)
{
int i;
static const struct option zero = INIT_OPTION(
NULL, 0, 0, 0, 0, 0, NULL, NULL);
/* To let unregister_options() correctly find the end of the
* info[] array, this loop must convert every element from
* struct option_init to struct option. That is, even if
* there is not enough memory to fully initialize some option,
* the loop must continue. */
for (i = 0; info[i].init.path; i++) {
/* Copy the value aside before it is overwritten
* with the other member of the union. */
const struct option_init init = info[i].init;
struct option *option = &info[i].option;
unsigned char *string;
*option = zero;
option->name = init.name;
option->capt = init.capt;
option->desc = init.desc;
option->flags = init.flags;
option->type = init.type;
option->min = init.min;
option->max = init.max;
/* init.value_long, init.value_dataptr, or init.value_funcptr
* is handled below as appropriate for each type. */
debug_check_option_syntax(option);
if (option->type != OPT_ALIAS
&& ((tree->flags & OPT_LISTBOX)
|| (option->flags & OPT_LISTBOX))) {
option->box_item = init_option_listbox_item(option);
if (!option->box_item) {
delete_option(option);
continue;
}
}
switch (option->type) {
case OPT_TREE:
option->value.tree = init_options_tree();
if (!option->value.tree) {
delete_option(option);
continue;
}
break;
case OPT_STRING:
string = mem_alloc(MAX_STR_LEN);
if (!string) {
delete_option(option);
continue;
}
safe_strncpy(string, init.value_dataptr, MAX_STR_LEN);
option->value.string = string;
break;
case OPT_COLOR:
string = init.value_dataptr;
assert(string);
decode_color(string, strlen(string),
&option->value.color);
break;
case OPT_CODEPAGE:
string = init.value_dataptr;
assert(string);
option->value.number = get_cp_index(string);
break;
case OPT_BOOL:
case OPT_INT:
option->value.number = init.value_long;
break;
case OPT_LONG:
option->value.big_number = init.value_long;
break;
case OPT_LANGUAGE:
/* INIT_OPT_LANGUAGE has no def parameter */
option->value.number = 0;
break;
case OPT_COMMAND:
option->value.command = init.value_funcptr;
break;
case OPT_ALIAS:
option->value.string = init.value_dataptr;
break;
}
add_opt_rec(tree, init.path, option);
}
/* Convert the sentinel at the end of the array, too. */
info[i].option = zero;
}
/*! @relates option_info */
void
unregister_options(union option_info info[], struct option *tree)
{
int i = 0;
/* We need to remove the options in inverse order to the order how we
* added them. */
while (info[i].option.name) i++;
for (i--; i >= 0; i--)
delete_option_do(&info[i].option, 0);
}