mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-29 14:38:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(options): reduce findoption() usage

Browse Source 
Problem: Many places in the code use `findoption()` to access an option using its name, even if the option index is available. This is very slow because it requires looping through the options array over and over.

Solution: Use option index instead of name wherever possible. Also introduce an `OptIndex` enum which contains the index for every option as enum constants, this eliminates the need to pass static option names as strings.
This commit is contained in:
Famiu Haque
2023-12-07 23:46:57 +06:00
parent 29aa4dd10a
commit 6346987601
39 changed files with 336 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
src/nvim/option.c
View File

@@ -156,19 +156,19 @@ typedef enum {
# include "options.generated.h"
#endif
static char *(p_bin_dep_opts[]) = {
"textwidth", "wrapmargin", "modeline", "expandtab", NULL
static int p_bin_dep_opts[] = {
kOptTextwidth, kOptWrapmargin, kOptModeline, kOptExpandtab, -1
};
static char *(p_paste_dep_opts[]) = {
"autoindent", "expandtab", "ruler", "showmatch", "smarttab",
"softtabstop", "textwidth", "wrapmargin", "revins", "varsofttabstop", NULL
static int p_paste_dep_opts[] = {
kOptAutoindent, kOptExpandtab, kOptRuler, kOptShowmatch, kOptSmarttab,
kOptSofttabstop, kOptTextwidth, kOptWrapmargin, kOptRevins, kOptVarsofttabstop, -1
};
void set_init_tablocal(void)
{
// susy baka: cmdheight calls itself OPT_GLOBAL but is really tablocal!
int ch_idx = findoption("cmdheight");
p_ch = (OptInt)(intptr_t)options[ch_idx].def_val;
p_ch = (OptInt)(intptr_t)options[kOptCmdheight].def_val;
}
/// Initialize the 'shell' option to a default value.
@@ -182,9 +182,9 @@ static void set_init_default_shell(void)
const size_t len = strlen(shell) + 3; // two quotes and a trailing NUL
char *const cmd = xmalloc(len);
snprintf(cmd, len, "\"%s\"", shell);
set_string_default("sh", cmd, true);
set_string_default(kOptShell, cmd, true);
} else {
set_string_default("sh", (char *)shell, false);
set_string_default(kOptShell, (char *)shell, false);
}
}
}
@@ -199,7 +199,7 @@ static void set_init_default_backupskip(void)
static char *(names[3]) = { "TMPDIR", "TEMP", "TMP" };
#endif
garray_T ga;
int opt_idx = findoption("backupskip");
int opt_idx = kOptBackupskip;
ga_init(&ga, 1, 100);
for (size_t n = 0; n < ARRAY_SIZE(names); n++) {
@@ -243,7 +243,7 @@ static void set_init_default_backupskip(void)
}
}
if (ga.ga_data != NULL) {
set_string_default("bsk", ga.ga_data, true);
set_string_default(kOptBackupskip, ga.ga_data, true);
}
}
@@ -269,7 +269,7 @@ static void set_init_default_cdpath(void)
}
}
buf[j] = NUL;
int opt_idx = findoption("cdpath");
int opt_idx = kOptCdpath;
if (opt_idx >= 0) {
options[opt_idx].def_val = buf;
options[opt_idx].flags |= P_DEF_ALLOCED;
@@ -346,20 +346,20 @@ void set_init_1(bool clean_arg)
backupdir = xrealloc(backupdir, backupdir_len + 3);
memmove(backupdir + 2, backupdir, backupdir_len + 1);
memmove(backupdir, ".,", 2);
set_string_default("backupdir", backupdir, true);
set_string_default("viewdir", stdpaths_user_state_subpath("view", 2, true),
set_string_default(kOptBackupdir, backupdir, true);
set_string_default(kOptViewdir, stdpaths_user_state_subpath("view", 2, true),
true);
set_string_default("directory", stdpaths_user_state_subpath("swap", 2, true),
set_string_default(kOptDirectory, stdpaths_user_state_subpath("swap", 2, true),
true);
set_string_default("undodir", stdpaths_user_state_subpath("undo", 2, true),
set_string_default(kOptUndodir, stdpaths_user_state_subpath("undo", 2, true),
true);
// Set default for &runtimepath. All necessary expansions are performed in
// this function.
char *rtp = runtimepath_default(clean_arg);
if (rtp) {
set_string_default("runtimepath", rtp, true);
set_string_default(kOptRuntimepath, rtp, true);
// Make a copy of 'rtp' for 'packpath'
set_string_default("packpath", rtp, false);
set_string_default(kOptPackpath, rtp, false);
rtp = NULL; // ownership taken
}
@@ -398,7 +398,7 @@ void set_init_1(bool clean_arg)
// NOTE: mlterm's author is being asked to 'set' a variable
// instead of an environment variable due to inheritance.
if (os_env_exists("MLTERM")) {
set_option_value_give_err("tbidi", BOOLEAN_OPTVAL(true), 0);
set_option_value_give_err(kOptTermbidi, BOOLEAN_OPTVAL(true), 0);
}
didset_options2();
@@ -430,10 +430,10 @@ static void set_option_default(const int opt_idx, int opt_flags)
uint32_t flags = opt->flags;
if (varp != NULL) { // skip hidden option, nothing to do for it
if (flags & P_STRING) {
// Use set_string_option_direct() for local options to handle
// freeing and allocating the value.
// Use set_string_option_direct() for local options to handle freeing and allocating the
// value.
if (opt->indir != PV_NONE) {
set_string_option_direct(NULL, opt_idx, opt->def_val, opt_flags, 0);
set_string_option_direct(opt_idx, opt->def_val, opt_flags, 0);
} else {
if ((opt_flags & OPT_FREE) && (flags & P_ALLOCED)) {
free_string_option(*(char **)(varp));
@@ -479,7 +479,7 @@ static void set_option_default(const int opt_idx, int opt_flags)
*flagsp = *flagsp & ~P_INSECURE;
}
set_option_sctx_idx(opt_idx, opt_flags, current_sctx);
set_option_sctx(opt_idx, opt_flags, current_sctx);
}
/// Set all options (except terminal options) to their default value.
@@ -504,22 +504,23 @@ static void set_options_default(int opt_flags)
/// Set the Vi-default value of a string option.
/// Used for 'sh', 'backupskip' and 'term'.
///
/// @param name The name of the option
/// @param val The value of the option
/// @param allocated If true, do not copy default as it was already allocated.
static void set_string_default(const char *name, char *val, bool allocated)
/// @param opt_idx Option index in options[] table.
/// @param val The value of the option.
/// @param allocated If true, do not copy default as it was already allocated.
static void set_string_default(int opt_idx, char *val, bool allocated)
FUNC_ATTR_NONNULL_ALL
{
int opt_idx = findoption(name);
if (opt_idx >= 0) {
vimoption_T *opt = &options[opt_idx];
if (opt->flags & P_DEF_ALLOCED) {
xfree(opt->def_val);
}
opt->def_val = allocated ? val : xstrdup(val);
opt->flags |= P_DEF_ALLOCED;
if (opt_idx < 0) {
return;
}
vimoption_T *opt = &options[opt_idx];
if (opt->flags & P_DEF_ALLOCED) {
xfree(opt->def_val);
}
opt->def_val = allocated ? val : xstrdup(val);
opt->flags |= P_DEF_ALLOCED;
}
/// For an option value that contains comma separated items, find "newval" in
@@ -555,9 +556,8 @@ static char *find_dup_item(char *origval, const char *newval, uint32_t flags)
/// Set the Vi-default value of a number option.
/// Used for 'lines' and 'columns'.
void set_number_default(char *name, OptInt val)
void set_number_default(int opt_idx, OptInt val)
{
int opt_idx = findoption(name);
if (opt_idx >= 0) {
options[opt_idx].def_val = (void *)(intptr_t)val;
}
@@ -597,18 +597,17 @@ void set_init_2(bool headless)
// 'scroll' defaults to half the window height. The stored default is zero,
// which results in the actual value computed from the window height.
int idx = findoption("scroll");
if (idx >= 0 && !(options[idx].flags & P_WAS_SET)) {
set_option_default(idx, OPT_LOCAL);
if (!(options[kOptScroll].flags & P_WAS_SET)) {
set_option_default(kOptScroll, OPT_LOCAL);
}
comp_col();
// 'window' is only for backwards compatibility with Vi.
// Default is Rows - 1.
if (!option_was_set("window")) {
if (!option_was_set(kOptWindow)) {
p_window = Rows - 1;
}
set_number_default("window", Rows - 1);
set_number_default(kOptWindow, Rows - 1);
}
/// Initialize the options, part three: After reading the .vimrc
@@ -619,14 +618,8 @@ void set_init_3(void)
// Set 'shellpipe' and 'shellredir', depending on the 'shell' option.
// This is done after other initializations, where 'shell' might have been
// set, but only if they have not been set before.
int idx_srr = findoption("srr");
int do_srr = (idx_srr < 0)
? false
: !(options[idx_srr].flags & P_WAS_SET);
int idx_sp = findoption("sp");
int do_sp = (idx_sp < 0)
? false
: !(options[idx_sp].flags & P_WAS_SET);
int do_srr = !(options[kOptShellredir].flags & P_WAS_SET);
int do_sp = !(options[kOptShellpipe].flags & P_WAS_SET);
size_t len = 0;
char *p = (char *)invocation_path_tail(p_sh, &len);
@@ -641,11 +634,11 @@ void set_init_3(void)
|| path_fnamecmp(p, "tcsh") == 0) {
if (do_sp) {
p_sp = "|& tee";
options[idx_sp].def_val = p_sp;
options[kOptShellpipe].def_val = p_sp;
}
if (do_srr) {
p_srr = ">&";
options[idx_srr].def_val = p_srr;
options[kOptShellredir].def_val = p_srr;
}
} else if (path_fnamecmp(p, "sh") == 0
|| path_fnamecmp(p, "ksh") == 0
@@ -660,11 +653,11 @@ void set_init_3(void)
// Always use POSIX shell style redirection if we reach this
if (do_sp) {
p_sp = "2>&1| tee";
options[idx_sp].def_val = p_sp;
options[kOptShellpipe].def_val = p_sp;
}
if (do_srr) {
p_srr = ">%s 2>&1";
options[idx_srr].def_val = p_srr;
options[kOptShellredir].def_val = p_srr;
}
}
xfree(p);
@@ -694,12 +687,11 @@ void set_helplang_default(const char *lang)
if (lang_len < 2) { // safety check
return;
}
int idx = findoption("hlg");
if (idx < 0 || (options[idx].flags & P_WAS_SET)) {
if (options[kOptHelplang].flags & P_WAS_SET) {
return;
}
if (options[idx].flags & P_ALLOCED) {
if (options[kOptHelplang].flags & P_ALLOCED) {
free_string_option(p_hlg);
}
p_hlg = xmemdupz(lang, lang_len);
@@ -713,7 +705,7 @@ void set_helplang_default(const char *lang)
p_hlg[1] = 'n';
}
p_hlg[2] = NUL;
options[idx].flags |= P_ALLOCED;
options[kOptHelplang].flags |= P_ALLOCED;
}
/// 'title' and 'icon' only default to true if they have not been set or reset
@@ -726,14 +718,12 @@ void set_title_defaults(void)
// If GUI is (going to be) used, we can always set the window title and
// icon name. Saves a bit of time, because the X11 display server does
// not need to be contacted.
int idx1 = findoption("title");
if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
options[idx1].def_val = 0;
if (!(options[kOptTitle].flags & P_WAS_SET)) {
options[kOptTitle].def_val = 0;
p_title = 0;
}
idx1 = findoption("icon");
if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
options[idx1].def_val = 0;
if (!(options[kOptIcon].flags & P_WAS_SET)) {
options[kOptIcon].def_val = 0;
p_icon = 0;
}
}
@@ -775,8 +765,7 @@ static char *stropt_get_default_val(int opt_idx, uint64_t flags)
}
/// Copy the new string value into allocated memory for the option.
/// Can't use set_string_option_direct(), because we need to remove the
/// backslashes.
/// Can't use set_string_option_direct(), because we need to remove the backslashes.
static char *stropt_copy_value(char *origval, char **argp, set_op_T op,
uint32_t flags FUNC_ATTR_UNUSED)
{
@@ -1707,19 +1696,19 @@ void check_options(void)
}
}
/// Return true when option "opt" was set from a modeline or in secure mode.
/// Return false when it wasn't.
/// Return -1 for an unknown option.
int was_set_insecurely(win_T *const wp, char *opt, int opt_flags)
/// Check if option was set insecurely.
///
/// @param wp Window.
/// @param opt_idx Option index in options[] table.
/// @param opt_flags Option flags.
///
/// @return True if option was set from a modeline or in secure mode, false if it wasn't.
int was_set_insecurely(win_T *const wp, int opt_idx, int opt_flags)
{
int idx = findoption(opt);
assert(opt_idx >= 0);
if (idx >= 0) {
uint32_t *flagp = insecure_flag(wp, idx, opt_flags);
return (*flagp & P_INSECURE) != 0;
}
internal_error("was_set_insecurely()");
return -1;
uint32_t *flagp = insecure_flag(wp, opt_idx, opt_flags);
return (*flagp & P_INSECURE) != 0;
}
/// Get a pointer to the flags used for the P_INSECURE flag of option
@@ -1829,21 +1818,16 @@ bool parse_winhl_opt(win_T *wp)
return true;
}
/// Get the script context of global option "name".
sctx_T *get_option_sctx(const char *const name)
/// Get the script context of global option at index opt_idx.
sctx_T *get_option_sctx(int opt_idx)
{
int idx = findoption(name);
if (idx >= 0) {
return &options[idx].last_set.script_ctx;
}
siemsg("no such option: %s", name);
return NULL;
assert(opt_idx >= 0);
return &options[opt_idx].last_set.script_ctx;
}
/// Set the script_ctx for an option, taking care of setting the buffer- or
/// window-local value.
void set_option_sctx_idx(int opt_idx, int opt_flags, sctx_T script_ctx)
void set_option_sctx(int opt_idx, int opt_flags, sctx_T script_ctx)
{
int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
int indir = (int)options[opt_idx].indir;
@@ -1952,7 +1936,7 @@ static const char *did_set_arabic(optset_T *args)
p_deco = true;
// Force-set the necessary keymap for arabic.
errmsg = set_option_value("keymap", STATIC_CSTR_AS_OPTVAL("arabic"), OPT_LOCAL);
errmsg = set_option_value(kOptKeymap, STATIC_CSTR_AS_OPTVAL("arabic"), OPT_LOCAL);
} else {
// 'arabic' is reset, handle various sub-settings.
if (!p_tbidi) {
@@ -2809,7 +2793,7 @@ static const char *check_num_option_bounds(OptInt *pp, OptInt old_value, char *e
cmdline_row = new_row;
}
}
if (p_window >= Rows || !option_was_set("window")) {
if (p_window >= Rows || !option_was_set(kOptWindow)) {
p_window = Rows - 1;
}
}
@@ -3590,7 +3574,7 @@ static const char *did_set_option(int opt_idx, void *varp, OptVal old_value, Opt
new_value = optval_from_varp(opt_idx, varp);
// Remember where the option was set.
set_option_sctx_idx(opt_idx, opt_flags, current_sctx);
set_option_sctx(opt_idx, opt_flags, current_sctx);
// Free options that are in allocated memory.
// Use "free_oldval", because recursiveness may change the flags (esp. init_highlight()).
if (free_oldval) {
@@ -3810,29 +3794,20 @@ err:
return errmsg;
}
/// Set the value of an option
/// Set the value of an option.
///
/// @param[in] name Option name.
/// @param opt_idx Index in options[] table. Must be >= 0.
/// @param[in] value Option value. If NIL_OPTVAL, the option value is cleared.
/// @param[in] opt_flags Flags: OPT_LOCAL, OPT_GLOBAL, or 0 (both).
///
/// @return NULL on success, an untranslated error message on error.
const char *set_option_value(const char *const name, const OptVal value, int opt_flags)
FUNC_ATTR_NONNULL_ARG(1)
const char *set_option_value(const int opt_idx, const OptVal value, int opt_flags)
{
assert(opt_idx >= 0);
static char errbuf[IOSIZE];
if (is_tty_option(name)) {
return NULL; // Fail silently; many old vimrcs set t_xx options.
}
int opt_idx = findoption(name);
if (opt_idx < 0) {
snprintf(errbuf, sizeof(errbuf), _(e_unknown_option2), name);
return errbuf;
}
uint32_t flags = options[opt_idx].flags;
// Disallow changing some options in the sandbox
if (sandbox > 0 && (flags & P_SECURE)) {
return _(e_sandbox);
@@ -3844,31 +3819,51 @@ const char *set_option_value(const char *const name, const OptVal value, int opt
return NULL;
}
const char *errmsg = NULL;
errmsg = set_option(opt_idx, varp, optval_copy(value), opt_flags, true, errbuf, sizeof(errbuf));
return errmsg;
return set_option(opt_idx, varp, optval_copy(value), opt_flags, true, errbuf, sizeof(errbuf));
}
/// Call set_option_value() and when an error is returned report it.
/// Set the value of an option. Supports TTY options, unlike set_option_value().
///
/// @param opt_flags OPT_LOCAL or 0 (both)
void set_option_value_give_err(const char *name, OptVal value, int opt_flags)
/// @param name Option name. Used for error messages and for setting TTY options.
/// @param opt_idx Option indx in options[] table. If less than zero, `name` is used to
/// check if the option is a TTY option, and an error is shown if it's not.
/// If the option is a TTY option, the function fails silently.
/// @param value Option value. If NIL_OPTVAL, the option value is cleared.
/// @param[in] opt_flags Flags: OPT_LOCAL, OPT_GLOBAL, or 0 (both).
///
/// @return NULL on success, an untranslated error message on error.
const char *set_option_value_handle_tty(const char *name, int opt_idx, const OptVal value,
int opt_flags)
FUNC_ATTR_NONNULL_ARG(1)
{
const char *errmsg = set_option_value(name, value, opt_flags);
static char errbuf[IOSIZE];
if (opt_idx < 0) {
if (is_tty_option(name)) {
return NULL; // Fail silently; many old vimrcs set t_xx options.
}
snprintf(errbuf, sizeof(errbuf), _(e_unknown_option2), name);
return errbuf;
}
return set_option_value(opt_idx, value, opt_flags);
}
/// Call set_option_value() and when an error is returned, report it.
///
/// @param opt_idx Option index in options[] table.
/// @param value Option value. If NIL_OPTVAL, the option value is cleared.
/// @param opt_flags OPT_LOCAL or 0 (both)
void set_option_value_give_err(const int opt_idx, OptVal value, int opt_flags)
{
const char *errmsg = set_option_value(opt_idx, value, opt_flags);
if (errmsg != NULL) {
emsg(_(errmsg));
}
}
bool is_option_allocated(const char *name)
{
int idx = findoption(name);
return idx >= 0 && (options[idx].flags & P_ALLOCED);
}
// Translate a string like "t_xx", "<t_xx>" or "<S-Tab>" to a key number.
// When "has_lt" is true there is a '<' before "*arg_arg".
// Returns 0 when the key is not recognized.
@@ -5155,14 +5150,9 @@ void buf_copy_options(buf_T *buf, int flags)
/// Reset the 'modifiable' option and its default value.
void reset_modifiable(void)
{
int opt_idx;
curbuf->b_p_ma = false;
p_ma = false;
opt_idx = findoption("ma");
if (opt_idx >= 0) {
options[opt_idx].def_val = false;
}
options[kOptModifiable].def_val = false;
}
/// Set the global value for 'iminsert' to the local value.
@@ -5807,35 +5797,24 @@ void vimrc_found(char *fname, char *envname)
}
}
/// Check whether global option has been set
/// Check whether global option has been set.
///
/// @param[in] name Option name.
///
/// @return True if it was set.
bool option_was_set(const char *name)
/// @return True if option was set.
bool option_was_set(int opt_idx)
{
int idx;
idx = findoption(name);
if (idx < 0) { // Unknown option.
return false;
} else if (options[idx].flags & P_WAS_SET) {
return true;
}
return false;
assert(opt_idx >= 0);
return options[opt_idx].flags & P_WAS_SET;
}
/// Reset the flag indicating option "name" was set.
///
/// @param[in] name Option name.
void reset_option_was_set(const char *name)
void reset_option_was_set(int opt_idx)
{
const int idx = findoption(name);
if (idx < 0) {
return;
}
options[idx].flags &= ~P_WAS_SET;
assert(opt_idx >= 0);
options[opt_idx].flags &= ~P_WAS_SET;
}
/// fill_culopt_flags() -- called when 'culopt' changes value
@@ -5934,17 +5913,14 @@ int option_set_callback_func(char *optval, Callback *optcb)
return OK;
}
static void didset_options_sctx(int opt_flags, char **buf)
static void didset_options_sctx(int opt_flags, int *buf)
{
for (int i = 0;; i++) {
if (buf[i] == NULL) {
if (buf[i] == -1) {
break;
}
int idx = findoption(buf[i]);
if (idx >= 0) {
set_option_sctx_idx(idx, opt_flags, current_sctx);
}
set_option_sctx(buf[i], opt_flags, current_sctx);
}
}
@@ -6084,7 +6060,7 @@ void set_fileformat(int eol_style, int opt_flags)
// p is NULL if "eol_style" is EOL_UNKNOWN.
if (p != NULL) {
set_string_option_direct("ff", -1, p, OPT_FREE | opt_flags, 0);
set_string_option_direct(kOptFileformat, p, OPT_FREE | opt_flags, 0);
}
// This may cause the buffer to become (un)modified.