diff options
Diffstat (limited to 'examples/dte/options.c')
| -rw-r--r-- | examples/dte/options.c | 987 |
1 files changed, 987 insertions, 0 deletions
diff --git a/examples/dte/options.c b/examples/dte/options.c new file mode 100644 index 0000000..2fd4190 --- /dev/null +++ b/examples/dte/options.c @@ -0,0 +1,987 @@ +#include <stdint.h> +#include <stdlib.h> +#include <string.h> +#include "options.h" +#include "buffer.h" +#include "command/serialize.h" +#include "editor.h" +#include "error.h" +#include "file-option.h" +#include "filetype.h" +#include "screen.h" +#include "status.h" +#include "terminal/output.h" +#include "util/bsearch.h" +#include "util/debug.h" +#include "util/intern.h" +#include "util/numtostr.h" +#include "util/str-util.h" +#include "util/string-view.h" +#include "util/strtonum.h" +#include "util/xmalloc.h" + +typedef enum { + OPT_STR, + OPT_UINT, + OPT_ENUM, + OPT_BOOL, + OPT_FLAG, + OPT_REGEX, +} OptionType; + +typedef union { + const char *str_val; // OPT_STR, OPT_REGEX + unsigned int uint_val; // OPT_UINT, OPT_ENUM, OPT_FLAG + bool bool_val; // OPT_BOOL +} OptionValue; + +typedef union { + struct {bool (*validate)(const char *value);} str_opt; // OPT_STR (optional) + struct {unsigned int min, max;} uint_opt; // OPT_UINT + struct {const char *const *values;} enum_opt; // OPT_ENUM, OPT_FLAG, OPT_BOOL +} OptionConstraint; + +typedef struct { + const char name[22]; + bool local; + bool global; + unsigned int offset; + OptionType type; + OptionConstraint u; + void (*on_change)(EditorState *e, bool global); // Optional +} OptionDesc; + +#define STR_OPT(_name, OLG, _validate, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_STR, \ + .u = {.str_opt = {.validate = _validate}}, \ + .on_change = _on_change, \ +} + +#define UINT_OPT(_name, OLG, _min, _max, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_UINT, \ + .u = {.uint_opt = { \ + .min = _min, \ + .max = _max, \ + }}, \ + .on_change = _on_change, \ +} + +#define ENUM_OPT(_name, OLG, _values, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_ENUM, \ + .u = {.enum_opt = {.values = _values}}, \ + .on_change = _on_change, \ +} + +#define FLAG_OPT(_name, OLG, _values, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_FLAG, \ + .u = {.enum_opt = {.values = _values}}, \ + .on_change = _on_change, \ +} + +#define BOOL_OPT(_name, OLG, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_BOOL, \ + .u = {.enum_opt = {.values = bool_enum}}, \ + .on_change = _on_change, \ +} + +#define REGEX_OPT(_name, OLG, _on_change) { \ + OLG \ + .name = _name, \ + .type = OPT_REGEX, \ + .on_change = _on_change, \ +} + +#define OLG(_offset, _local, _global) \ + .offset = _offset, \ + .local = _local, \ + .global = _global, \ + +#define L(member) OLG(offsetof(LocalOptions, member), true, false) +#define G(member) OLG(offsetof(GlobalOptions, member), false, true) +#define C(member) OLG(offsetof(CommonOptions, member), true, true) + +static void filetype_changed(EditorState *e, bool global) +{ + BUG_ON(!e->buffer); + BUG_ON(global); + set_file_options(e, e->buffer); + buffer_update_syntax(e, e->buffer); +} + +static void set_window_title_changed(EditorState *e, bool global) +{ + BUG_ON(!global); + Terminal *term = &e->terminal; + if (e->options.set_window_title) { + if (e->status == EDITOR_RUNNING) { + update_term_title(term, e->buffer, e->options.set_window_title); + } + } else { + term_restore_title(term); + term_save_title(term); + } +} + +static void syntax_changed(EditorState *e, bool global) +{ + if (e->buffer && !global) { + buffer_update_syntax(e, e->buffer); + } +} + +static void overwrite_changed(EditorState *e, bool global) +{ + if (!global) { + e->cursor_style_changed = true; + } +} + +static void redraw_buffer(EditorState *e, bool global) +{ + if (e->buffer && !global) { + mark_all_lines_changed(e->buffer); + } +} + +static void redraw_screen(EditorState *e, bool global) +{ + BUG_ON(!global); + mark_everything_changed(e); +} + +static bool validate_statusline_format(const char *value) +{ + size_t errpos = statusline_format_find_error(value); + if (likely(errpos == 0)) { + return true; + } + char ch = value[errpos]; + if (ch == '\0') { + return error_msg("Format character expected after '%%'"); + } + return error_msg("Invalid format character '%c'", ch); +} + +static bool validate_filetype(const char *value) +{ + if (!is_valid_filetype_name(value)) { + return error_msg("Invalid filetype name '%s'", value); + } + return true; +} + +static OptionValue str_get(const OptionDesc* UNUSED_ARG(desc), void *ptr) +{ + const char *const *strp = ptr; + return (OptionValue){.str_val = *strp}; +} + +static void str_set(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + const char **strp = ptr; + *strp = str_intern(v.str_val); +} + +static bool str_parse(const OptionDesc *d, const char *str, OptionValue *v) +{ + bool valid = !d->u.str_opt.validate || d->u.str_opt.validate(str); + v->str_val = valid ? str : NULL; + return valid; +} + +static const char *str_string(const OptionDesc* UNUSED_ARG(d), OptionValue v) +{ + const char *s = v.str_val; + return s ? s : ""; +} + +static bool str_equals(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + const char **strp = ptr; + return xstreq(*strp, v.str_val); +} + +static OptionValue re_get(const OptionDesc* UNUSED_ARG(desc), void *ptr) +{ + const InternedRegexp *const *irp = ptr; + return (OptionValue){.str_val = *irp ? (*irp)->str : NULL}; +} + +static void re_set(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + const InternedRegexp **irp = ptr; + *irp = v.str_val ? regexp_intern(v.str_val) : NULL; +} + +static bool re_parse(const OptionDesc* UNUSED_ARG(d), const char *str, OptionValue *v) +{ + if (str[0] == '\0') { + v->str_val = NULL; + return true; + } + + bool valid = regexp_is_interned(str) || regexp_is_valid(str, REG_NEWLINE); + v->str_val = valid ? str : NULL; + return valid; +} + +static bool re_equals(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + const InternedRegexp **irp = ptr; + return *irp ? xstreq((*irp)->str, v.str_val) : !v.str_val; +} + +static OptionValue uint_get(const OptionDesc* UNUSED_ARG(desc), void *ptr) +{ + const unsigned int *valp = ptr; + return (OptionValue){.uint_val = *valp}; +} + +static void uint_set(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + unsigned int *valp = ptr; + *valp = v.uint_val; +} + +static bool uint_parse(const OptionDesc *d, const char *str, OptionValue *v) +{ + unsigned int val; + if (!str_to_uint(str, &val)) { + return error_msg("Integer value for %s expected", d->name); + } + + const unsigned int min = d->u.uint_opt.min; + const unsigned int max = d->u.uint_opt.max; + if (val < min || val > max) { + return error_msg("Value for %s must be in %u-%u range", d->name, min, max); + } + + v->uint_val = val; + return true; +} + +static const char *uint_string(const OptionDesc* UNUSED_ARG(desc), OptionValue value) +{ + return uint_to_str(value.uint_val); +} + +static bool uint_equals(const OptionDesc* UNUSED_ARG(desc), void *ptr, OptionValue value) +{ + const unsigned int *valp = ptr; + return *valp == value.uint_val; +} + +static OptionValue bool_get(const OptionDesc* UNUSED_ARG(d), void *ptr) +{ + const bool *valp = ptr; + return (OptionValue){.bool_val = *valp}; +} + +static void bool_set(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + bool *valp = ptr; + *valp = v.bool_val; +} + +static bool bool_parse(const OptionDesc *d, const char *str, OptionValue *v) +{ + if (streq(str, "true")) { + v->bool_val = true; + return true; + } else if (streq(str, "false")) { + v->bool_val = false; + return true; + } + return error_msg("Invalid value for %s", d->name); +} + +static const char *bool_string(const OptionDesc* UNUSED_ARG(d), OptionValue v) +{ + return v.bool_val ? "true" : "false"; +} + +static bool bool_equals(const OptionDesc* UNUSED_ARG(d), void *ptr, OptionValue v) +{ + const bool *valp = ptr; + return *valp == v.bool_val; +} + +static bool enum_parse(const OptionDesc *d, const char *str, OptionValue *v) +{ + const char *const *values = d->u.enum_opt.values; + unsigned int i; + for (i = 0; values[i]; i++) { + if (streq(values[i], str)) { + v->uint_val = i; + return true; + } + } + + unsigned int val; + if (!str_to_uint(str, &val) || val >= i) { + return error_msg("Invalid value for %s", d->name); + } + + v->uint_val = val; + return true; +} + +static const char *enum_string(const OptionDesc *desc, OptionValue value) +{ + return desc->u.enum_opt.values[value.uint_val]; +} + +static bool flag_parse(const OptionDesc *d, const char *str, OptionValue *v) +{ + // "0" is allowed for compatibility and is the same as "" + if (str[0] == '0' && str[1] == '\0') { + v->uint_val = 0; + return true; + } + + const char *const *values = d->u.enum_opt.values; + unsigned int flags = 0; + + for (size_t pos = 0, len = strlen(str); pos < len; ) { + const StringView flag = get_delim(str, &pos, len, ','); + size_t i; + for (i = 0; values[i]; i++) { + if (strview_equal_cstring(&flag, values[i])) { + flags |= 1u << i; + break; + } + } + if (unlikely(!values[i])) { + int flen = (int)flag.length; + return error_msg("Invalid flag '%.*s' for %s", flen, flag.data, d->name); + } + } + + v->uint_val = flags; + return true; +} + +static const char *flag_string(const OptionDesc *desc, OptionValue value) +{ + static char buf[128]; + unsigned int flags = value.uint_val; + if (!flags) { + buf[0] = '0'; + buf[1] = '\0'; + return buf; + } + + char *ptr = buf; + const char *const *values = desc->u.enum_opt.values; + for (size_t i = 0, avail = sizeof(buf); values[i]; i++) { + if (flags & (1u << i)) { + char *next = memccpy(ptr, values[i], '\0', avail); + if (DEBUG >= 1) { + BUG_ON(!next); + avail -= (size_t)(next - ptr); + } + ptr = next; + ptr[-1] = ','; + } + } + + BUG_ON(ptr == buf); + ptr[-1] = '\0'; + return buf; +} + +static const struct { + OptionValue (*get)(const OptionDesc *desc, void *ptr); + void (*set)(const OptionDesc *desc, void *ptr, OptionValue value); + bool (*parse)(const OptionDesc *desc, const char *str, OptionValue *value); + const char *(*string)(const OptionDesc *desc, OptionValue value); + bool (*equals)(const OptionDesc *desc, void *ptr, OptionValue value); +} option_ops[] = { + [OPT_STR] = {str_get, str_set, str_parse, str_string, str_equals}, + [OPT_UINT] = {uint_get, uint_set, uint_parse, uint_string, uint_equals}, + [OPT_ENUM] = {uint_get, uint_set, enum_parse, enum_string, uint_equals}, + [OPT_BOOL] = {bool_get, bool_set, bool_parse, bool_string, bool_equals}, + [OPT_FLAG] = {uint_get, uint_set, flag_parse, flag_string, uint_equals}, + [OPT_REGEX] = {re_get, re_set, re_parse, str_string, re_equals}, +}; + +static const char *const bool_enum[] = {"false", "true", NULL}; +static const char *const newline_enum[] = {"unix", "dos", NULL}; +static const char *const tristate_enum[] = {"false", "true", "auto", NULL}; +static const char *const save_unmodified_enum[] = {"none", "touch", "full", NULL}; + +static const char *const detect_indent_values[] = { + "1", "2", "3", "4", "5", "6", "7", "8", + NULL +}; + +// Note: this must be kept in sync with WhitespaceErrorFlags +static const char *const ws_error_values[] = { + "space-indent", + "space-align", + "tab-indent", + "tab-after-indent", + "special", + "auto-indent", + "trailing", + "all-trailing", + NULL +}; + +static const OptionDesc option_desc[] = { + BOOL_OPT("auto-indent", C(auto_indent), NULL), + BOOL_OPT("brace-indent", L(brace_indent), NULL), + ENUM_OPT("case-sensitive-search", G(case_sensitive_search), tristate_enum, NULL), + FLAG_OPT("detect-indent", C(detect_indent), detect_indent_values, NULL), + BOOL_OPT("display-special", G(display_special), redraw_screen), + BOOL_OPT("editorconfig", C(editorconfig), NULL), + BOOL_OPT("emulate-tab", C(emulate_tab), NULL), + UINT_OPT("esc-timeout", G(esc_timeout), 0, 2000, NULL), + BOOL_OPT("expand-tab", C(expand_tab), redraw_buffer), + BOOL_OPT("file-history", C(file_history), NULL), + UINT_OPT("filesize-limit", G(filesize_limit), 0, 16000, NULL), + STR_OPT("filetype", L(filetype), validate_filetype, filetype_changed), + BOOL_OPT("fsync", C(fsync), NULL), + REGEX_OPT("indent-regex", L(indent_regex), NULL), + UINT_OPT("indent-width", C(indent_width), 1, INDENT_WIDTH_MAX, NULL), + BOOL_OPT("lock-files", G(lock_files), NULL), + ENUM_OPT("newline", G(crlf_newlines), newline_enum, NULL), + BOOL_OPT("optimize-true-color", G(optimize_true_color), redraw_screen), + BOOL_OPT("overwrite", C(overwrite), overwrite_changed), + ENUM_OPT("save-unmodified", C(save_unmodified), save_unmodified_enum, NULL), + UINT_OPT("scroll-margin", G(scroll_margin), 0, 100, redraw_screen), + BOOL_OPT("select-cursor-char", G(select_cursor_char), redraw_screen), + BOOL_OPT("set-window-title", G(set_window_title), set_window_title_changed), + BOOL_OPT("show-line-numbers", G(show_line_numbers), redraw_screen), + STR_OPT("statusline-left", G(statusline_left), validate_statusline_format, NULL), + STR_OPT("statusline-right", G(statusline_right), validate_statusline_format, NULL), + BOOL_OPT("syntax", C(syntax), syntax_changed), + BOOL_OPT("tab-bar", G(tab_bar), redraw_screen), + UINT_OPT("tab-width", C(tab_width), 1, TAB_WIDTH_MAX, redraw_buffer), + UINT_OPT("text-width", C(text_width), 1, TEXT_WIDTH_MAX, NULL), + BOOL_OPT("utf8-bom", G(utf8_bom), NULL), + FLAG_OPT("ws-error", C(ws_error), ws_error_values, redraw_buffer), +}; + +static char *local_ptr(const OptionDesc *desc, LocalOptions *opt) +{ + BUG_ON(!desc->local); + return (char*)opt + desc->offset; +} + +static char *global_ptr(const OptionDesc *desc, GlobalOptions *opt) +{ + BUG_ON(!desc->global); + return (char*)opt + desc->offset; +} + +static char *get_option_ptr(EditorState *e, const OptionDesc *d, bool global) +{ + return global ? global_ptr(d, &e->options) : local_ptr(d, &e->buffer->options); +} + +static inline size_t count_enum_values(const OptionDesc *desc) +{ + OptionType type = desc->type; + BUG_ON(type != OPT_ENUM && type != OPT_FLAG && type != OPT_BOOL); + const char *const *values = desc->u.enum_opt.values; + BUG_ON(!values); + return string_array_length((char**)values); +} + +UNITTEST { + static const struct { + size_t alignment; + size_t size; + } map[] = { + [OPT_STR] = {ALIGNOF(const char*), sizeof(const char*)}, + [OPT_UINT] = {ALIGNOF(unsigned int), sizeof(unsigned int)}, + [OPT_ENUM] = {ALIGNOF(unsigned int), sizeof(unsigned int)}, + [OPT_BOOL] = {ALIGNOF(bool), sizeof(bool)}, + [OPT_FLAG] = {ALIGNOF(unsigned int), sizeof(unsigned int)}, + [OPT_REGEX] = {ALIGNOF(const InternedRegexp*), sizeof(const InternedRegexp*)}, + }; + + GlobalOptions gopts = {.tab_bar = true}; + LocalOptions lopts = {.filetype = NULL}; + + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + const OptionType type = desc->type; + BUG_ON(type >= ARRAYLEN(map)); + size_t alignment = map[type].alignment; + size_t end = desc->offset + map[type].size; + if (desc->global) { + uintptr_t ptr_val = (uintptr_t)global_ptr(desc, &gopts); + BUG_ON(ptr_val % alignment != 0); + BUG_ON(end > sizeof(GlobalOptions)); + } + if (desc->local) { + uintptr_t ptr_val = (uintptr_t)local_ptr(desc, &lopts); + BUG_ON(ptr_val % alignment != 0); + BUG_ON(end > sizeof(LocalOptions)); + } + if (desc->global && desc->local) { + BUG_ON(end > sizeof(CommonOptions)); + } + if (type == OPT_UINT) { + BUG_ON(desc->u.uint_opt.max <= desc->u.uint_opt.min); + } else if (type == OPT_BOOL) { + BUG_ON(desc->u.enum_opt.values != bool_enum); + } else if (type == OPT_ENUM) { + BUG_ON(count_enum_values(desc) < 2); + } else if (type == OPT_FLAG) { + size_t nvals = count_enum_values(desc); + OptionValue val = {.uint_val = -1}; + BUG_ON(nvals < 2); + BUG_ON(nvals >= BITSIZE(val.uint_val)); + const char *str = flag_string(desc, val); + BUG_ON(!str); + BUG_ON(str[0] == '\0'); + if (!flag_parse(desc, str, &val)) { + BUG("flag_parse() failed for string: %s", str); + } + unsigned int mask = (1u << nvals) - 1; + if (val.uint_val != mask) { + BUG("values not equal: %u, %u", val.uint_val, mask); + } + } + } + + // Ensure option_desc[] is properly sorted + CHECK_BSEARCH_ARRAY(option_desc, name, strcmp); +} + +static OptionValue desc_get(const OptionDesc *desc, void *ptr) +{ + return option_ops[desc->type].get(desc, ptr); +} + +static void desc_set(EditorState *e, const OptionDesc *desc, void *ptr, bool global, OptionValue value) +{ + option_ops[desc->type].set(desc, ptr, value); + if (desc->on_change) { + desc->on_change(e, global); + } +} + +static bool desc_parse(const OptionDesc *desc, const char *str, OptionValue *value) +{ + return option_ops[desc->type].parse(desc, str, value); +} + +static const char *desc_string(const OptionDesc *desc, OptionValue value) +{ + return option_ops[desc->type].string(desc, value); +} + +static bool desc_equals(const OptionDesc *desc, void *ptr, OptionValue value) +{ + return option_ops[desc->type].equals(desc, ptr, value); +} + +static int option_cmp(const void *key, const void *elem) +{ + const char *name = key; + const OptionDesc *desc = elem; + return strcmp(name, desc->name); +} + +static const OptionDesc *find_option(const char *name) +{ + return BSEARCH(name, option_desc, option_cmp); +} + +static const OptionDesc *must_find_option(const char *name) +{ + const OptionDesc *desc = find_option(name); + if (!desc) { + error_msg("No such option %s", name); + } + return desc; +} + +static const OptionDesc *must_find_global_option(const char *name) +{ + const OptionDesc *desc = must_find_option(name); + if (desc && !desc->global) { + error_msg("Option %s is not global", name); + return NULL; + } + return desc; +} + +static bool do_set_option ( + EditorState *e, + const OptionDesc *desc, + const char *value, + bool local, + bool global +) { + if (local && !desc->local) { + return error_msg("Option %s is not local", desc->name); + } + if (global && !desc->global) { + return error_msg("Option %s is not global", desc->name); + } + + OptionValue val; + if (!desc_parse(desc, value, &val)) { + return false; + } + + if (!local && !global) { + // Set both by default + local = desc->local; + global = desc->global; + } + + if (local) { + desc_set(e, desc, local_ptr(desc, &e->buffer->options), false, val); + } + if (global) { + desc_set(e, desc, global_ptr(desc, &e->options), true, val); + } + + return true; +} + +bool set_option(EditorState *e, const char *name, const char *value, bool local, bool global) +{ + const OptionDesc *desc = must_find_option(name); + if (!desc) { + return false; + } + return do_set_option(e, desc, value, local, global); +} + +bool set_bool_option(EditorState *e, const char *name, bool local, bool global) +{ + const OptionDesc *desc = must_find_option(name); + if (!desc) { + return false; + } + if (desc->type != OPT_BOOL) { + return error_msg("Option %s is not boolean", desc->name); + } + return do_set_option(e, desc, "true", local, global); +} + +static const OptionDesc *find_toggle_option(const char *name, bool *global) +{ + if (*global) { + return must_find_global_option(name); + } + + // Toggle local value by default if option has both values + const OptionDesc *desc = must_find_option(name); + if (desc && !desc->local) { + *global = true; + } + return desc; +} + +bool toggle_option(EditorState *e, const char *name, bool global, bool verbose) +{ + const OptionDesc *desc = find_toggle_option(name, &global); + if (!desc) { + return false; + } + + char *ptr = get_option_ptr(e, desc, global); + OptionValue value = desc_get(desc, ptr); + OptionType type = desc->type; + if (type == OPT_ENUM) { + if (desc->u.enum_opt.values[value.uint_val + 1]) { + value.uint_val++; + } else { + value.uint_val = 0; + } + } else if (type == OPT_BOOL) { + value.bool_val = !value.bool_val; + } else { + return error_msg("Toggling %s requires arguments", name); + } + + desc_set(e, desc, ptr, global, value); + if (verbose) { + const char *prefix = (global && desc->local) ? "[global] " : ""; + const char *str = desc_string(desc, value); + info_msg("%s%s = %s", prefix, desc->name, str); + } + + return true; +} + +bool toggle_option_values ( + EditorState *e, + const char *name, + bool global, + bool verbose, + char **values, + size_t count +) { + const OptionDesc *desc = find_toggle_option(name, &global); + if (!desc) { + return false; + } + + BUG_ON(count == 0); + size_t current = 0; + bool error = false; + char *ptr = get_option_ptr(e, desc, global); + OptionValue *parsed_values = xnew(OptionValue, count); + + for (size_t i = 0; i < count; i++) { + if (desc_parse(desc, values[i], &parsed_values[i])) { + if (desc_equals(desc, ptr, parsed_values[i])) { + current = i + 1; + } + } else { + error = true; + } + } + + if (!error) { + size_t i = current % count; + desc_set(e, desc, ptr, global, parsed_values[i]); + if (verbose) { + const char *prefix = (global && desc->local) ? "[global] " : ""; + const char *str = desc_string(desc, parsed_values[i]); + info_msg("%s%s = %s", prefix, desc->name, str); + } + } + + free(parsed_values); + return !error; +} + +bool validate_local_options(char **strs) +{ + size_t invalid = 0; + for (size_t i = 0; strs[i]; i += 2) { + const char *name = strs[i]; + const char *value = strs[i + 1]; + const OptionDesc *desc = must_find_option(name); + if (unlikely(!desc)) { + invalid++; + } else if (unlikely(!desc->local)) { + error_msg("%s is not local", name); + invalid++; + } else if (unlikely(desc->on_change == filetype_changed)) { + error_msg("filetype cannot be set via option command"); + invalid++; + } else { + OptionValue val; + if (unlikely(!desc_parse(desc, value, &val))) { + invalid++; + } + } + } + return !invalid; +} + +#if DEBUG >= 1 +static void sanity_check_option_value(const OptionDesc *desc, OptionValue val) +{ + switch (desc->type) { + case OPT_STR: + BUG_ON(!val.str_val); + BUG_ON(val.str_val != str_intern(val.str_val)); + if (desc->u.str_opt.validate) { + BUG_ON(!desc->u.str_opt.validate(val.str_val)); + } + return; + case OPT_UINT: + BUG_ON(val.uint_val < desc->u.uint_opt.min); + BUG_ON(val.uint_val > desc->u.uint_opt.max); + return; + case OPT_ENUM: + BUG_ON(val.uint_val >= count_enum_values(desc)); + return; + case OPT_FLAG: { + size_t nvals = count_enum_values(desc); + BUG_ON(nvals >= 32); + unsigned int mask = (1u << nvals) - 1; + unsigned int uint_val = val.uint_val; + BUG_ON((uint_val & mask) != uint_val); + } + return; + case OPT_REGEX: + BUG_ON(val.str_val && val.str_val[0] == '\0'); + BUG_ON(val.str_val && !regexp_is_interned(val.str_val)); + return; + case OPT_BOOL: + return; + } + + BUG("unhandled option type"); +} + +static void sanity_check_options(const void *opts, bool global) +{ + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + BUG_ON(desc->type >= ARRAYLEN(option_ops)); + if ((desc->global && desc->local) || global == desc->global) { + OptionValue val = desc_get(desc, (char*)opts + desc->offset); + sanity_check_option_value(desc, val); + } + } +} + +void sanity_check_global_options(const GlobalOptions *gopts) +{ + sanity_check_options(gopts, true); +} + +void sanity_check_local_options(const LocalOptions *lopts) +{ + sanity_check_options(lopts, false); +} +#endif + +void collect_options(PointerArray *a, const char *prefix, bool local, bool global) +{ + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + if ((local && !desc->local) || (global && !desc->global)) { + continue; + } + if (str_has_prefix(desc->name, prefix)) { + ptr_array_append(a, xstrdup(desc->name)); + } + } +} + +// Collect options that can be set via the "option" command +void collect_auto_options(PointerArray *a, const char *prefix) +{ + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + if (!desc->local || desc->on_change == filetype_changed) { + continue; + } + if (str_has_prefix(desc->name, prefix)) { + ptr_array_append(a, xstrdup(desc->name)); + } + } +} + +void collect_toggleable_options(PointerArray *a, const char *prefix, bool global) +{ + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + if (global && !desc->global) { + continue; + } + OptionType type = desc->type; + bool toggleable = (type == OPT_ENUM || type == OPT_BOOL); + if (toggleable && str_has_prefix(desc->name, prefix)) { + ptr_array_append(a, xstrdup(desc->name)); + } + } +} + +void collect_option_values(EditorState *e, PointerArray *a, const char *option, const char *prefix) +{ + const OptionDesc *desc = find_option(option); + if (!desc) { + return; + } + + if (prefix[0] == '\0') { + char *ptr = get_option_ptr(e, desc, !desc->local); + OptionValue value = desc_get(desc, ptr); + ptr_array_append(a, xstrdup(desc_string(desc, value))); + return; + } + + OptionType type = desc->type; + if (type == OPT_STR || type == OPT_UINT || type == OPT_REGEX) { + return; + } + + const char *const *values = desc->u.enum_opt.values; + if (type == OPT_ENUM || type == OPT_BOOL) { + for (size_t i = 0; values[i]; i++) { + if (str_has_prefix(values[i], prefix)) { + ptr_array_append(a, xstrdup(values[i])); + } + } + return; + } + + BUG_ON(type != OPT_FLAG); + const char *comma = strrchr(prefix, ','); + size_t prefix_len = comma ? ++comma - prefix : 0; + for (size_t i = 0; values[i]; i++) { + const char *str = values[i]; + if (str_has_prefix(str, prefix + prefix_len)) { + size_t str_len = strlen(str); + char *completion = xmalloc(prefix_len + str_len + 1); + memcpy(completion, prefix, prefix_len); + memcpy(completion + prefix_len, str, str_len + 1); + ptr_array_append(a, completion); + } + } +} + +static void append_option(String *s, const OptionDesc *desc, void *ptr) +{ + const OptionValue value = desc_get(desc, ptr); + const char *value_str = desc_string(desc, value); + if (unlikely(value_str[0] == '-')) { + string_append_literal(s, "-- "); + } + string_append_cstring(s, desc->name); + string_append_byte(s, ' '); + string_append_escaped_arg(s, value_str, true); + string_append_byte(s, '\n'); +} + +String dump_options(GlobalOptions *gopts, LocalOptions *lopts) +{ + String buf = string_new(4096); + for (size_t i = 0; i < ARRAYLEN(option_desc); i++) { + const OptionDesc *desc = &option_desc[i]; + void *local = desc->local ? local_ptr(desc, lopts) : NULL; + void *global = desc->global ? global_ptr(desc, gopts) : NULL; + if (local && global) { + const OptionValue global_value = desc_get(desc, global); + if (desc_equals(desc, local, global_value)) { + string_append_literal(&buf, "set "); + append_option(&buf, desc, local); + } else { + string_append_literal(&buf, "set -g "); + append_option(&buf, desc, global); + string_append_literal(&buf, "set -l "); + append_option(&buf, desc, local); + } + } else { + string_append_literal(&buf, "set "); + append_option(&buf, desc, local ? local : global); + } + } + return buf; +} + +const char *get_option_value_string(EditorState *e, const char *name) +{ + const OptionDesc *desc = find_option(name); + if (!desc) { + return NULL; + } + char *ptr = get_option_ptr(e, desc, !desc->local); + return desc_string(desc, desc_get(desc, ptr)); +} |