kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-19 18:55:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #26458 from famiu/refactor/options/optionindex

Browse Source
This commit is contained in:
dundargoc 2023-12-10 16:26:08 +01:00 committed by GitHub
commit 529498685b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 492 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/nvim/CMakeLists.txt
View File

@ -324,6 +324,7 @@ set(GENERATED_KEYSETS_DEFS ${GENERATED_DIR}/keysets_defs.generated.h)
set(GENERATED_EVENTS_ENUM ${GENERATED_INCLUDES_DIR}/auevents_enum.generated.h)
set(GENERATED_EVENTS_NAMES_MAP ${GENERATED_DIR}/auevents_name_map.generated.h)
set(GENERATED_OPTIONS ${GENERATED_DIR}/options.generated.h)
set(GENERATED_OPTIONS_ENUM ${GENERATED_DIR}/options_enum.generated.h)
set(EX_CMDS_GENERATOR ${GENERATOR_DIR}/gen_ex_cmds.lua)
set(FUNCS_GENERATOR ${GENERATOR_DIR}/gen_eval.lua)
set(EVENTS_GENERATOR ${GENERATOR_DIR}/gen_events.lua)
@ -668,8 +669,8 @@ add_custom_command(OUTPUT ${GENERATED_EVENTS_ENUM} ${GENERATED_EVENTS_NAMES_MAP}
DEPENDS ${LUA_GEN_DEPS} ${EVENTS_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}/auevents.lua
)
add_custom_command(OUTPUT ${GENERATED_OPTIONS}
COMMAND ${LUA_GEN} ${OPTIONS_GENERATOR} ${GENERATED_OPTIONS}
add_custom_command(OUTPUT ${GENERATED_OPTIONS} ${GENERATED_OPTIONS_ENUM}
COMMAND ${LUA_GEN} ${OPTIONS_GENERATOR} ${GENERATED_OPTIONS} ${GENERATED_OPTIONS_ENUM}
DEPENDS ${LUA_GEN_DEPS} ${OPTIONS_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}/options.lua
)

11
src/nvim/api/deprecated.c
View File

@ -643,7 +643,7 @@ static Object get_option_from(void *from, OptReqScope req_scope, String name, Er
return (Object)OBJECT_INIT;
});
OptVal value = get_option_value_strict(name.data, req_scope, from, err);
OptVal value = get_option_value_strict(findoption(name.data), req_scope, from, err);
if (ERROR_SET(err)) {
return (Object)OBJECT_INIT;
}
@ -669,8 +669,8 @@ static void set_option_to(uint64_t channel_id, void *to, OptReqScope req_scope,
return;
});
int flags = get_option_attrs(name.data);
VALIDATE_S(flags != 0, "option name", name.data, {
OptIndex opt_idx = findoption(name.data);
VALIDATE_S(opt_idx != kOptInvalid, "option name", name.data, {
return;
});
@ -685,13 +685,14 @@ static void set_option_to(uint64_t channel_id, void *to, OptReqScope req_scope,
return;
});
int attrs = get_option_attrs(opt_idx);
// For global-win-local options -> setlocal
// For win-local options -> setglobal and setlocal (opt_flags == 0)
const int opt_flags = (req_scope == kOptReqWin && !(flags & SOPT_GLOBAL))
const int opt_flags = (req_scope == kOptReqWin && !(attrs & SOPT_GLOBAL))
? 0
: (req_scope == kOptReqGlobal) ? OPT_GLOBAL : OPT_LOCAL;
WITH_SCRIPT_CONTEXT(channel_id, {
set_option_value_for(name.data, optval, opt_flags, req_scope, to, err);
set_option_value_for(name.data, opt_idx, optval, opt_flags, req_scope, to, err);
});
}

77
src/nvim/api/options.c
View File

@ -23,9 +23,9 @@
# include "api/options.c.generated.h"
#endif
static int validate_option_value_args(Dict(option) *opts, char *name, int *scope,
OptReqScope *req_scope, void **from, char **filetype,
Error *err)
static int validate_option_value_args(Dict(option) *opts, char *name, OptIndex *opt_idxp,
int *scope, OptReqScope *req_scope, void **from,
char **filetype, Error *err)
{
#define HAS_KEY_X(d, v) HAS_KEY(d, option, v)
if (HAS_KEY_X(opts, scope)) {
@ -79,7 +79,8 @@ static int validate_option_value_args(Dict(option) *opts, char *name, int *scope
return FAIL;
});
int flags = get_option_attrs(name);
*opt_idxp = findoption(name);
int flags = get_option_attrs(*opt_idxp);
if (flags == 0) {
// hidden or unknown option
api_set_error(err, kErrorTypeValidation, "Unknown option '%s'", name);
@ -119,10 +120,10 @@ static buf_T *do_ft_buf(char *filetype, aco_save_T *aco, Error *err)
aucmd_prepbuf(aco, ftbuf);
TRY_WRAP(err, {
set_option_value("bufhidden", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
set_option_value("buftype", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value("swapfile", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value("modeline", BOOLEAN_OPTVAL(false), OPT_LOCAL); // 'nomodeline'
set_option_value(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
set_option_value(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value(kOptModeline, BOOLEAN_OPTVAL(false), OPT_LOCAL); // 'nomodeline'
ftbuf->b_p_ft = xstrdup(filetype);
do_filetype_autocmd(ftbuf, false);
@ -152,12 +153,14 @@ static buf_T *do_ft_buf(char *filetype, aco_save_T *aco, Error *err)
Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
FUNC_API_SINCE(9)
{
OptIndex opt_idx = 0;
int scope = 0;
OptReqScope req_scope = kOptReqGlobal;
void *from = NULL;
char *filetype = NULL;
if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &from, &filetype, err)) {
if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &from, &filetype,
err)) {
return (Object)OBJECT_INIT;
}
@ -173,7 +176,6 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
from = ftbuf;
}
int opt_idx = findoption(name.data);
OptVal value = get_option_value_for(opt_idx, scope, req_scope, from, err);
bool hidden = is_option_hidden(opt_idx);
@ -217,10 +219,11 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
Error *err)
FUNC_API_SINCE(9)
{
OptIndex opt_idx = 0;
int scope = 0;
OptReqScope req_scope = kOptReqGlobal;
void *to = NULL;
if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &to, NULL, err)) {
if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &to, NULL, err)) {
return;
}
@ -231,7 +234,7 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
//
// Then force scope to local since we don't want to change the global option
if (req_scope == kOptReqWin && scope == 0) {
int flags = get_option_attrs(name.data);
int flags = get_option_attrs(opt_idx);
if (flags & SOPT_GLOBAL) {
scope = OPT_LOCAL;
}
@ -249,7 +252,7 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
});
WITH_SCRIPT_CONTEXT(channel_id, {
set_option_value_for(name.data, optval, scope, req_scope, to, err);
set_option_value_for(name.data, opt_idx, optval, scope, req_scope, to, err);
});
}
@ -303,10 +306,12 @@ Dictionary nvim_get_all_options_info(Error *err)
Dictionary nvim_get_option_info2(String name, Dict(option) *opts, Error *err)
FUNC_API_SINCE(11)
{
OptIndex opt_idx = 0;
int scope = 0;
OptReqScope req_scope = kOptReqGlobal;
void *from = NULL;
if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &from, NULL, err)) {
if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &from, NULL,
err)) {
return (Dictionary)ARRAY_DICT_INIT;
}
@ -382,20 +387,14 @@ static void restore_option_context(void *const ctx, OptReqScope req_scope)
/// Get attributes for an option.
///
/// @param name Option name.
/// @param opt_idx Option index in options[] table.
///
/// @return Option attributes.
/// 0 for hidden or unknown option.
/// See SOPT_* in option_defs.h for other flags.
int get_option_attrs(char *name)
int get_option_attrs(OptIndex opt_idx)
{
if (is_tty_option(name)) {
return SOPT_GLOBAL;
}
int opt_idx = findoption(name);
if (opt_idx < 0) {
if (opt_idx == kOptInvalid) {
return 0;
}
@ -422,15 +421,13 @@ int get_option_attrs(char *name)
/// Check if option has a value in the requested scope.
///
/// @param name Option name.
/// @param opt_idx Option index in options[] table.
/// @param req_scope Requested option scope. See OptReqScope in option.h.
///
/// @return true if option has a value in the requested scope, false otherwise.
static bool option_has_scope(char *name, OptReqScope req_scope)
static bool option_has_scope(OptIndex opt_idx, OptReqScope req_scope)
{
int opt_idx = findoption(name);
if (opt_idx < 0) {
if (opt_idx == kOptInvalid) {
return false;
}
@ -458,7 +455,7 @@ static bool option_has_scope(char *name, OptReqScope req_scope)
/// Get the option value in the requested scope.
///
/// @param name Option name.
/// @param opt_idx Option index in options[] table.
/// @param req_scope Requested option scope. See OptReqScope in option.h.
/// @param[in] from Pointer to buffer or window for local option value.
/// @param[out] err Error message, if any.
@ -466,17 +463,11 @@ static bool option_has_scope(char *name, OptReqScope req_scope)
/// @return Option value in the requested scope. Returns a Nil option value if option is not found,
/// hidden or if it isn't present in the requested scope. (i.e. has no global, window-local or
/// buffer-local value depending on opt_scope).
OptVal get_option_value_strict(char *name, OptReqScope req_scope, void *from, Error *err)
OptVal get_option_value_strict(OptIndex opt_idx, OptReqScope req_scope, void *from, Error *err)
{
if (!option_has_scope(name, req_scope)) {
if (opt_idx == kOptInvalid || !option_has_scope(opt_idx, req_scope)) {
return NIL_OPTVAL;
}
if (is_tty_option(name)) {
return get_tty_option(name);
}
int opt_idx = findoption(name);
assert(opt_idx != 0); // option_has_scope() already verifies if option name is valid.
vimoption_T *opt = get_option(opt_idx);
switchwin_T switchwin;
@ -509,8 +500,8 @@ OptVal get_option_value_strict(char *name, OptReqScope req_scope, void *from, Er
/// @param[out] err Error message, if any.
///
/// @return Option value. Must be freed by caller.
OptVal get_option_value_for(int opt_idx, int scope, const OptReqScope req_scope, void *const from,
Error *err)
OptVal get_option_value_for(OptIndex opt_idx, int scope, const OptReqScope req_scope,
void *const from, Error *err)
{
switchwin_T switchwin;
aco_save_T aco;
@ -533,14 +524,16 @@ OptVal get_option_value_for(int opt_idx, int scope, const OptReqScope req_scope,
/// Set option value for buffer / window.
///
/// @param[in] name Option name.
/// @param name Option name.
/// @param opt_idx Option index in options[] table.
/// @param[in] value Option value.
/// @param[in] opt_flags Flags: OPT_LOCAL, OPT_GLOBAL, or 0 (both).
/// @param req_scope Requested option scope. See OptReqScope in option.h.
/// @param[in] from Target buffer/window.
/// @param[out] err Error message, if any.
void set_option_value_for(const char *const name, OptVal value, const int opt_flags,
void set_option_value_for(const char *name, OptIndex opt_idx, OptVal value, const int opt_flags,
const OptReqScope req_scope, void *const from, Error *err)
FUNC_ATTR_NONNULL_ARG(1)
{
switchwin_T switchwin;
aco_save_T aco;
@ -552,7 +545,7 @@ void set_option_value_for(const char *const name, OptVal value, const int opt_fl
return;
}
const char *const errmsg = set_option_value(name, value, opt_flags);
const char *const errmsg = set_option_value_handle_tty(name, opt_idx, value, opt_flags);
if (errmsg) {
api_set_error(err, kErrorTypeException, "%s", errmsg);
}

6
src/nvim/api/vim.c
View File

@ -948,8 +948,8 @@ Buffer nvim_create_buf(Boolean listed, Boolean scratch, Error *err)
buf_copy_options(buf, BCO_ENTER | BCO_NOHELP);
if (scratch) {
set_string_option_direct_in_buf(buf, "bufhidden", -1, "hide", OPT_LOCAL, 0);
set_string_option_direct_in_buf(buf, "buftype", -1, "nofile", OPT_LOCAL, 0);
set_string_option_direct_in_buf(buf, kOptBufhidden, "hide", OPT_LOCAL, 0);
set_string_option_direct_in_buf(buf, kOptBuftype, "nofile", OPT_LOCAL, 0);
assert(buf->b_ml.ml_mfp->mf_fd < 0); // ml_open() should not have opened swapfile already
buf->b_p_swf = false;
buf->b_p_ml = false;
@ -2239,7 +2239,7 @@ Dictionary nvim_eval_statusline(String str, Dict(eval_statusline) *opts, Error *
buf,
sizeof(buf),
str.data,
NULL,
-1,
0,
fillchar,
maxwidth,

4
src/nvim/autocmd.c
View File

@ -704,7 +704,7 @@ char *au_event_disable(char *what)
} else {
STRCAT(new_ei, what);
}
set_string_option_direct("ei", -1, new_ei, OPT_FREE, SID_NONE);
set_string_option_direct(kOptEventignore, new_ei, OPT_FREE, SID_NONE);
xfree(new_ei);
return save_ei;
}
@ -712,7 +712,7 @@ char *au_event_disable(char *what)
void au_event_restore(char *old_ei)
{
if (old_ei != NULL) {
set_string_option_direct("ei", -1, old_ei, OPT_FREE, SID_NONE);
set_string_option_direct(kOptEventignore, old_ei, OPT_FREE, SID_NONE);
xfree(old_ei);
}
}

10
src/nvim/buffer.c
View File

@ -3281,7 +3281,7 @@ void maketitle(void)
if (*p_titlestring != NUL) {
if (stl_syntax & STL_IN_TITLE) {
build_stl_str_hl(curwin, buf, sizeof(buf), p_titlestring,
"titlestring", 0, 0, maxlen, NULL, NULL, NULL);
kOptTitlestring, 0, 0, maxlen, NULL, NULL, NULL);
title_str = buf;
} else {
title_str = p_titlestring;
@ -3386,7 +3386,7 @@ void maketitle(void)
if (*p_iconstring != NUL) {
if (stl_syntax & STL_IN_ICON) {
build_stl_str_hl(curwin, icon_str, sizeof(buf), p_iconstring,
"iconstring", 0, 0, 0, NULL, NULL, NULL);
kOptIconstring, 0, 0, 0, NULL, NULL, NULL);
} else {
icon_str = p_iconstring;
}
@ -4147,9 +4147,9 @@ int buf_open_scratch(handle_T bufnr, char *bufname)
apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, false, curbuf);
(void)setfname(curbuf, bufname, NULL, true);
apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, curbuf);
set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
RESET_BINDING(curwin);
return OK;
}

6
src/nvim/context.c
View File

@ -138,8 +138,8 @@ bool ctx_restore(Context *ctx, const int flags)
free_ctx = true;
}
OptVal op_shada = get_option_value(findoption("shada"), OPT_GLOBAL);
set_option_value("shada", STATIC_CSTR_AS_OPTVAL("!,'100,%"), OPT_GLOBAL);
OptVal op_shada = get_option_value(kOptShada, OPT_GLOBAL);
set_option_value(kOptShada, STATIC_CSTR_AS_OPTVAL("!,'100,%"), OPT_GLOBAL);
if (flags & kCtxRegs) {
ctx_restore_regs(ctx);
@ -165,7 +165,7 @@ bool ctx_restore(Context *ctx, const int flags)
ctx_free(ctx);
}
set_option_value("shada", op_shada, OPT_GLOBAL);
set_option_value(kOptShada, op_shada, OPT_GLOBAL);
optval_free(op_shada);
return true;

4
src/nvim/diff.c
View File

@ -1389,7 +1389,7 @@ static void set_diff_option(win_T *wp, bool value)
curwin = wp;
curbuf = curwin->w_buffer;
curbuf->b_ro_locked++;
set_option_value_give_err("diff", BOOLEAN_OPTVAL(value), OPT_LOCAL);
set_option_value_give_err(kOptDiff, BOOLEAN_OPTVAL(value), OPT_LOCAL);
curbuf->b_ro_locked--;
curwin = old_curwin;
curbuf = curwin->w_buffer;
@ -1430,7 +1430,7 @@ void diff_win_options(win_T *wp, int addbuf)
}
wp->w_p_fdm_save = xstrdup(wp->w_p_fdm);
}
set_string_option_direct_in_win(wp, "fdm", -1, "diff", OPT_LOCAL | OPT_FREE, 0);
set_string_option_direct_in_win(wp, kOptFoldmethod, "diff", OPT_LOCAL | OPT_FREE, 0);
if (!wp->w_p_diff) {
wp->w_p_fen_save = wp->w_p_fen;

18
src/nvim/eval.c
View File

@ -681,7 +681,7 @@ int eval_charconvert(const char *const enc_from, const char *const enc_to,
set_vim_var_string(VV_CC_TO, enc_to, -1);
set_vim_var_string(VV_FNAME_IN, fname_from, -1);
set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
sctx_T *ctx = get_option_sctx("charconvert");
sctx_T *ctx = get_option_sctx(kOptCharconvert);
if (ctx != NULL) {
current_sctx = *ctx;
}
@ -710,7 +710,7 @@ void eval_diff(const char *const origfile, const char *const newfile, const char
set_vim_var_string(VV_FNAME_NEW, newfile, -1);
set_vim_var_string(VV_FNAME_OUT, outfile, -1);
sctx_T *ctx = get_option_sctx("diffexpr");
sctx_T *ctx = get_option_sctx(kOptDiffexpr);
if (ctx != NULL) {
current_sctx = *ctx;
}
@ -732,7 +732,7 @@ void eval_patch(const char *const origfile, const char *const difffile, const ch
set_vim_var_string(VV_FNAME_DIFF, difffile, -1);
set_vim_var_string(VV_FNAME_OUT, outfile, -1);
sctx_T *ctx = get_option_sctx("patchexpr");
sctx_T *ctx = get_option_sctx(kOptPatchexpr);
if (ctx != NULL) {
current_sctx = *ctx;
}
@ -1134,7 +1134,7 @@ list_T *eval_spell_expr(char *badword, char *expr)
if (p_verbose == 0) {
emsg_off++;
}
sctx_T *ctx = get_option_sctx("spellsuggest");
sctx_T *ctx = get_option_sctx(kOptSpellsuggest);
if (ctx != NULL) {
current_sctx = *ctx;
}
@ -1278,7 +1278,7 @@ void *call_func_retlist(const char *func, int argc, typval_T *argv)
int eval_foldexpr(win_T *wp, int *cp)
{
const sctx_T saved_sctx = current_sctx;
const bool use_sandbox = was_set_insecurely(wp, "foldexpr", OPT_LOCAL);
const bool use_sandbox = was_set_insecurely(wp, kOptFoldexpr, OPT_LOCAL);
char *arg = wp->w_p_fde;
current_sctx = wp->w_p_script_ctx[WV_FDE].script_ctx;
@ -1326,7 +1326,7 @@ int eval_foldexpr(win_T *wp, int *cp)
/// Evaluate 'foldtext', returning an Array or a String (NULL_STRING on failure).
Object eval_foldtext(win_T *wp)
{
const bool use_sandbox = was_set_insecurely(wp, "foldtext", OPT_LOCAL);
const bool use_sandbox = was_set_insecurely(wp, kOptFoldtext, OPT_LOCAL);
char *arg = wp->w_p_fdt;
funccal_entry_T funccal_entry;
@ -3788,9 +3788,9 @@ int eval_option(const char **const arg, typval_T *const rettv, const bool evalua
*option_end = NUL;
bool is_tty_opt = is_tty_option(*arg);
int opt_idx = is_tty_opt ? -1 : findoption(*arg);
OptIndex opt_idx = is_tty_opt ? kOptInvalid : findoption(*arg);
if (opt_idx < 0 && !is_tty_opt) {
if (opt_idx == kOptInvalid && !is_tty_opt) {
// Only give error if result is going to be used.
if (rettv != NULL) {
semsg(_("E113: Unknown option: %s"), *arg);
@ -8715,7 +8715,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, const char
// If it's still empty it was changed and restored, need to restore in
// the complicated way.
if (*p_cpo == NUL) {
set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
}
free_string_option(save_cpo);
}

2
src/nvim/eval/funcs.c
View File

@ -7239,7 +7239,7 @@ int do_searchpair(const char *spat, const char *mpat, const char *epat, int dir,
// If it's still empty it was changed and restored, need to restore in
// the complicated way.
if (*p_cpo == NUL) {
set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
}
free_string_option(save_cpo);
}

17
src/nvim/eval/vars.c
View File

@ -774,7 +774,7 @@ static char *ex_let_option(char *arg, typval_T *const tv, const bool is_const,
*p = NUL;
bool is_tty_opt = is_tty_option(arg);
int opt_idx = is_tty_opt ? -1 : findoption(arg);
OptIndex opt_idx = is_tty_opt ? kOptInvalid : findoption(arg);
uint32_t opt_p_flags = get_option_flags(opt_idx);
bool hidden = is_option_hidden(opt_idx);
OptVal curval = is_tty_opt ? get_tty_option(arg) : get_option_value(opt_idx, scope);
@ -834,7 +834,7 @@ static char *ex_let_option(char *arg, typval_T *const tv, const bool is_const,
}
}
const char *err = set_option_value(arg, newval, scope);
const char *err = set_option_value_handle_tty(arg, opt_idx, newval, scope);
arg_end = p;
if (err != NULL) {
emsg(_(err));
@ -1940,20 +1940,23 @@ typval_T optval_as_tv(OptVal value)
/// Set option "varname" to the value of "varp" for the current buffer/window.
static void set_option_from_tv(const char *varname, typval_T *varp)
{
int opt_idx = findoption(varname);
if (opt_idx < 0) {
OptIndex opt_idx = findoption(varname);
if (opt_idx == kOptInvalid) {
semsg(_(e_unknown_option2), varname);
return;
}
uint32_t opt_p_flags = get_option(opt_idx)->flags;
bool error = false;
uint32_t opt_p_flags = get_option_flags(opt_idx);
OptVal value = tv_to_optval(varp, varname, opt_p_flags, &error);
if (!error) {
set_option_value_give_err(varname, value, OPT_LOCAL);
}
const char *errmsg = set_option_value_handle_tty(varname, opt_idx, value, OPT_LOCAL);
if (errmsg) {
emsg(errmsg);
}
}
optval_free(value);
}

10
src/nvim/ex_cmds.c
View File

@ -4265,7 +4265,7 @@ skip:
// Show 'inccommand' preview if there are matched lines.
if (cmdpreview_ns > 0 && !aborting()) {
if (got_quit || profile_passed_limit(timeout)) { // Too slow, disable.
set_string_option_direct("icm", -1, "", OPT_FREE, SID_NONE);
set_string_option_direct(kOptInccommand, "", OPT_FREE, SID_NONE);
} else if (*p_icm != NUL && pat != NULL) {
if (pre_hl_id == 0) {
pre_hl_id = syn_check_group(S_LEN("Substitute"));
@ -4544,8 +4544,8 @@ bool prepare_tagpreview(bool undo_sync)
curwin->w_p_wfh = true;
RESET_BINDING(curwin); // don't take over 'scrollbind' and 'cursorbind'
curwin->w_p_diff = false; // no 'diff'
set_string_option_direct("fdc", -1, // no 'foldcolumn'
"0", OPT_FREE, SID_NONE);
set_string_option_direct(kOptFoldcolumn, "0", OPT_FREE, SID_NONE); // no 'foldcolumn'
return true;
}
@ -4564,7 +4564,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
buf_T *cmdpreview_buf = NULL;
// disable file info message
set_string_option_direct("shm", -1, "F", OPT_FREE, SID_NONE);
set_string_option_direct(kOptShortmess, "F", OPT_FREE, SID_NONE);
// Update the topline to ensure that main window is on the correct line
update_topline(curwin);
@ -4665,7 +4665,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
xfree(str);
set_string_option_direct("shm", -1, save_shm_p, OPT_FREE, SID_NONE);
set_string_option_direct(kOptShortmess, save_shm_p, OPT_FREE, SID_NONE);
xfree(save_shm_p);
return preview ? 2 : 1;

6
src/nvim/ex_docmd.c
View File

@ -2653,7 +2653,7 @@ static void apply_cmdmod(cmdmod_T *cmod)
// Set 'eventignore' to "all".
// First save the existing option value for restoring it later.
cmod->cmod_save_ei = xstrdup(p_ei);
set_string_option_direct("ei", -1, "all", OPT_FREE, SID_NONE);
set_string_option_direct(kOptEventignore, "all", OPT_FREE, SID_NONE);
}
}
@ -2673,7 +2673,7 @@ void undo_cmdmod(cmdmod_T *cmod)
if (cmod->cmod_save_ei != NULL) {
// Restore 'eventignore' to the value before ":noautocmd".
set_string_option_direct("ei", -1, cmod->cmod_save_ei, OPT_FREE, SID_NONE);
set_string_option_direct(kOptEventignore, cmod->cmod_save_ei, OPT_FREE, SID_NONE);
free_string_option(cmod->cmod_save_ei);
cmod->cmod_save_ei = NULL;
}
@ -7306,7 +7306,7 @@ static void ex_setfiletype(exarg_T *eap)
arg += 9;
}
set_option_value_give_err("filetype", CSTR_AS_OPTVAL(arg), OPT_LOCAL);
set_option_value_give_err(kOptFiletype, CSTR_AS_OPTVAL(arg), OPT_LOCAL);
if (arg != eap->arg) {
did_filetype = false;
}

6
src/nvim/ex_getln.c
View File

@ -905,7 +905,7 @@ static uint8_t *command_line_enter(int firstc, int count, int indent, bool clear
need_wait_return = false;
}
set_string_option_direct("icm", -1, s->save_p_icm, OPT_FREE, SID_NONE);
set_string_option_direct(kOptInccommand, s->save_p_icm, OPT_FREE, SID_NONE);
State = s->save_State;
if (cmdpreview != save_cmdpreview) {
cmdpreview = save_cmdpreview; // restore preview state
@ -4326,7 +4326,7 @@ static int open_cmdwin(void)
return Ctrl_C;
}
// Command-line buffer has bufhidden=wipe, unlike a true "scratch" buffer.
set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
curbuf->b_p_ma = true;
curwin->w_p_fen = false;
curwin->w_p_rl = cmdmsg_rl;
@ -4344,7 +4344,7 @@ static int open_cmdwin(void)
add_map("<Tab>", "<C-X><C-V>", MODE_INSERT, true);
add_map("<Tab>", "a<C-X><C-V>", MODE_NORMAL, true);
}
set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("vim"), OPT_LOCAL);
set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("vim"), OPT_LOCAL);
}
curbuf->b_ro_locked--;

4
src/nvim/fileio.c
View File

@ -1617,7 +1617,7 @@ failed:
save_file_ff(curbuf);
// If editing a new file: set 'fenc' for the current buffer.
// Also for ":read ++edit file".
set_string_option_direct("fenc", -1, fenc, OPT_FREE | OPT_LOCAL, 0);
set_string_option_direct(kOptFileencoding, fenc, OPT_FREE | OPT_LOCAL, 0);
}
if (fenc_alloced) {
xfree(fenc);
@ -1965,7 +1965,7 @@ void set_forced_fenc(exarg_T *eap)
}
char *fenc = enc_canonize(eap->cmd + eap->force_enc);
set_string_option_direct("fenc", -1, fenc, OPT_FREE|OPT_LOCAL, 0);
set_string_option_direct(kOptFileencoding, fenc, OPT_FREE|OPT_LOCAL, 0);
xfree(fenc);
}

23
src/nvim/generators/gen_options.lua
View File

@ -1,4 +1,5 @@
local options_file = arg[1]
local options_enum_file = arg[2]
local opt_fd = assert(io.open(options_file, 'w'))
@ -41,6 +42,12 @@ local list_flags = {
flagscomma = 'P_COMMA|P_FLAGLIST',
}
--- @param s string
--- @return string
local lowercase_to_titlecase = function(s)
return s:sub(1, 1):upper() .. s:sub(2)
end
--- @param o vim.option_meta
--- @return string
local function get_flags(o)
@ -222,11 +229,25 @@ static vimoption_T options[] = {]])
for i, o in ipairs(options.options) do
dump_option(i, o)
end
w(' [' .. ('%u'):format(#options.options) .. ']={.fullname=NULL}')
w('};')
w('')
for _, v in ipairs(defines) do
w('#define ' .. v[1] .. ' ' .. v[2])
end
-- Generate options enum file
opt_fd = assert(io.open(options_enum_file, 'w'))
w('typedef enum {')
w(' kOptInvalid = -1,')
for i, o in ipairs(options.options) do
w((' kOpt%s = %u,'):format(lowercase_to_titlecase(o.full_name), i - 1))
end
w(' // Option count, used when iterating through options')
w('#define kOptIndexCount ' .. tostring(#options.options))
w('} OptIndex;')
opt_fd:close()

8
src/nvim/help.c
View File

@ -608,7 +608,7 @@ void cleanup_help_tags(int num_file, char **file)
void prepare_help_buffer(void)
{
curbuf->b_help = true;
set_string_option_direct("buftype", -1, "help", OPT_FREE|OPT_LOCAL, 0);
set_string_option_direct(kOptBuftype, "help", OPT_FREE|OPT_LOCAL, 0);
// Always set these options after jumping to a help tag, because the
// user may have an autocommand that gets in the way.
@ -617,13 +617,13 @@ void prepare_help_buffer(void)
// Only set it when needed, buf_init_chartab() is some work.
char *p = "!-~,^*,^|,^\",192-255";
if (strcmp(curbuf->b_p_isk, p) != 0) {
set_string_option_direct("isk", -1, p, OPT_FREE|OPT_LOCAL, 0);
set_string_option_direct(kOptIskeyword, p, OPT_FREE|OPT_LOCAL, 0);
check_buf_options(curbuf);
(void)buf_init_chartab(curbuf, false);
}
// Don't use the global foldmethod.
set_string_option_direct("fdm", -1, "manual", OPT_FREE|OPT_LOCAL, 0);
set_string_option_direct(kOptFoldmethod, "manual", OPT_FREE|OPT_LOCAL, 0);
curbuf->b_p_ts = 8; // 'tabstop' is 8.
curwin->w_p_list = false; // No list mode.
@ -649,7 +649,7 @@ void fix_help_buffer(void)
// Set filetype to "help".
if (strcmp(curbuf->b_p_ft, "help") != 0) {
curbuf->b_ro_locked++;
set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("help"), OPT_LOCAL);
set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("help"), OPT_LOCAL);
curbuf->b_ro_locked--;
}

7
src/nvim/highlight_group.c
View File

@ -1337,9 +1337,10 @@ void do_highlight(const char *line, const bool forceit, const bool init)
// wrong.
if (dark != -1
&& dark != (*p_bg == 'd')
&& !option_was_set("bg")) {
set_option_value_give_err("bg", CSTR_AS_OPTVAL(dark ? "dark" : "light"), 0);
reset_option_was_set("bg");
&& !option_was_set(kOptBackground)) {
set_option_value_give_err(kOptBackground,
CSTR_AS_OPTVAL(dark ? "dark" : "light"), 0);
reset_option_was_set(kOptBackground);
}
}
}

4
src/nvim/indent.c
View File

@ -1091,7 +1091,7 @@ void ex_retab(exarg_T *eap)
colnr_T *old_vts_ary = curbuf->b_p_vts_array;
if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1) {
set_string_option_direct("vts", -1, new_ts_str, OPT_FREE | OPT_LOCAL, 0);
set_string_option_direct(kOptVartabstop, new_ts_str, OPT_FREE | OPT_LOCAL, 0);
curbuf->b_p_vts_array = new_vts_array;
xfree(old_vts_ary);
} else {
@ -1115,7 +1115,7 @@ int get_expr_indent(void)
colnr_T save_curswant;
int save_set_curswant;
int save_State;
int use_sandbox = was_set_insecurely(curwin, "indentexpr", OPT_LOCAL);
int use_sandbox = was_set_insecurely(curwin, kOptIndentexpr, OPT_LOCAL);
const sctx_T save_sctx = current_sctx;
// Save and restore cursor position and curswant, in case it was changed

24
src/nvim/main.c
View File

@ -1123,7 +1123,7 @@ static void command_line_scan(mparm_T *parmp)
} else if (STRNICMP(argv[0] + argv_idx, "clean", 5) == 0) {
parmp->use_vimrc = "NONE";
parmp->clean = true;
set_option_value_give_err("shadafile", STATIC_CSTR_AS_OPTVAL("NONE"), 0);
set_option_value_give_err(kOptShadafile, STATIC_CSTR_AS_OPTVAL("NONE"), 0);
} else if (STRNICMP(argv[0] + argv_idx, "luamod-dev", 9) == 0) {
nlua_disable_preload = true;
} else {
@ -1137,7 +1137,7 @@ static void command_line_scan(mparm_T *parmp)
}
break;
case 'A': // "-A" start in Arabic mode.
set_option_value_give_err("arabic", BOOLEAN_OPTVAL(true), 0);
set_option_value_give_err(kOptArabic, BOOLEAN_OPTVAL(true), 0);
break;
case 'b': // "-b" binary mode.
// Needs to be effective before expanding file names, because
@ -1167,8 +1167,8 @@ static void command_line_scan(mparm_T *parmp)
usage();
os_exit(0);
case 'H': // "-H" start in Hebrew mode: rl + keymap=hebrew set.
set_option_value_give_err("keymap", STATIC_CSTR_AS_OPTVAL("hebrew"), 0);
set_option_value_give_err("rl", BOOLEAN_OPTVAL(true), 0);
set_option_value_give_err(kOptKeymap, STATIC_CSTR_AS_OPTVAL("hebrew"), 0);
set_option_value_give_err(kOptRightleft, BOOLEAN_OPTVAL(true), 0);
break;
case 'M': // "-M" no changes or writing of files
reset_modifiable();
@ -1248,7 +1248,7 @@ static void command_line_scan(mparm_T *parmp)
// default is 10: a little bit verbose
p_verbose = get_number_arg(argv[0], &argv_idx, 10);
if (argv[0][argv_idx] != NUL) {
set_option_value_give_err("verbosefile", CSTR_AS_OPTVAL(argv[0] + argv_idx), 0);
set_option_value_give_err(kOptVerbosefile, CSTR_AS_OPTVAL(argv[0] + argv_idx), 0);
argv_idx = (int)strlen(argv[0]);
}
break;
@ -1256,7 +1256,7 @@ static void command_line_scan(mparm_T *parmp)
// "-w {scriptout}" write to script
if (ascii_isdigit((argv[0])[argv_idx])) {
n = get_number_arg(argv[0], &argv_idx, 10);
set_option_value_give_err("window", NUMBER_OPTVAL((OptInt)n), 0);
set_option_value_give_err(kOptWindow, NUMBER_OPTVAL((OptInt)n), 0);
break;
}
want_argument = true;
@ -1352,7 +1352,7 @@ static void command_line_scan(mparm_T *parmp)
break;
case 'i': // "-i {shada}" use for shada
set_option_value_give_err("shadafile", CSTR_AS_OPTVAL(argv[0]), 0);
set_option_value_give_err(kOptShadafile, CSTR_AS_OPTVAL(argv[0]), 0);
break;
case 'l': // "-l" Lua script: args after "-l".
@ -1362,7 +1362,7 @@ static void command_line_scan(mparm_T *parmp)
parmp->no_swap_file = true;
parmp->use_vimrc = parmp->use_vimrc ? parmp->use_vimrc : "NONE";
if (p_shadafile == NULL || *p_shadafile == NUL) {
set_option_value_give_err("shadafile", STATIC_CSTR_AS_OPTVAL("NONE"), 0);
set_option_value_give_err(kOptShadafile, STATIC_CSTR_AS_OPTVAL("NONE"), 0);
}
parmp->luaf = argv[0];
argc--;
@ -1398,7 +1398,7 @@ scripterror:
if (ascii_isdigit(*(argv[0]))) {
argv_idx = 0;
n = get_number_arg(argv[0], &argv_idx, 10);
set_option_value_give_err("window", NUMBER_OPTVAL((OptInt)n), 0);
set_option_value_give_err(kOptWindow, NUMBER_OPTVAL((OptInt)n), 0);
argv_idx = -1;
break;
}
@ -1549,7 +1549,7 @@ static void handle_quickfix(mparm_T *paramp)
{
if (paramp->edit_type == EDIT_QF) {
if (paramp->use_ef != NULL) {
set_string_option_direct("ef", -1, paramp->use_ef, OPT_FREE, SID_CARG);
set_string_option_direct(kOptErrorfile, paramp->use_ef, OPT_FREE, SID_CARG);
}
vim_snprintf(IObuff, IOSIZE, "cfile %s", p_ef);
if (qf_init(NULL, p_ef, p_efm, true, IObuff, p_menc) < 0) {
@ -1794,7 +1794,7 @@ static void edit_buffers(mparm_T *parmp, char *cwd)
p_shm_save = xstrdup(p_shm);
snprintf(buf, sizeof(buf), "F%s", p_shm);
set_option_value_give_err("shm", CSTR_AS_OPTVAL(buf), 0);
set_option_value_give_err(kOptShortmess, CSTR_AS_OPTVAL(buf), 0);
}
} else {
if (curwin->w_next == NULL) { // just checking
@ -1839,7 +1839,7 @@ static void edit_buffers(mparm_T *parmp, char *cwd)
}
if (p_shm_save != NULL) {
set_option_value_give_err("shm", CSTR_AS_OPTVAL(p_shm_save), 0);
set_option_value_give_err(kOptShortmess, CSTR_AS_OPTVAL(p_shm_save), 0);
xfree(p_shm_save);
}

2
src/nvim/memline.c
View File

@ -974,7 +974,7 @@ void ml_recover(bool checkext)
set_fileformat(b0_ff - 1, OPT_LOCAL);
}
if (b0_fenc != NULL) {
set_option_value_give_err("fenc", CSTR_AS_OPTVAL(b0_fenc), OPT_LOCAL);
set_option_value_give_err(kOptFileencoding, CSTR_AS_OPTVAL(b0_fenc), OPT_LOCAL);
xfree(b0_fenc);
}
unchanged(curbuf, true, true);

544
src/nvim/option.c
View File

File diff suppressed because it is too large Load Diff

2
src/nvim/option.h
View File

@ -87,7 +87,7 @@ typedef enum {
OPT_SKIPRTP = 0x100, ///< "skiprtp" in 'sessionoptions'
} OptionFlags;
/// Return value from get_option_value_strict
/// Return value from get_option_attrs().
enum {
SOPT_GLOBAL = 0x01, ///< Option has global value
SOPT_WIN = 0x02, ///< Option has window-local value

5
src/nvim/option_defs.h
View File

@ -122,3 +122,8 @@ typedef enum {
kOptReqWin = 1, ///< Request window-local option value
kOptReqBuf = 2, ///< Request buffer-local option value
} OptReqScope;
#ifdef INCLUDE_GENERATED_DECLARATIONS
// Initialize the OptIndex enum.
# include "options_enum.generated.h"
#endif

85
src/nvim/optionstr.c
View File

@ -283,7 +283,7 @@ static void set_string_option_global(vimoption_T *opt, char **varp)
/// Set a string option to a new value (without checking the effect).
/// The string is copied into allocated memory.
/// if ("opt_idx" == -1) "name" is used, otherwise "opt_idx" is used.
/// if ("opt_idx" == kOptInvalid) "name" is used, otherwise "opt_idx" is used.
/// When "set_sid" is zero set the scriptID to current_sctx.sc_sid. When
/// "set_sid" is SID_NONE don't set the scriptID. Otherwise set the scriptID to
/// "set_sid".
@ -291,22 +291,9 @@ static void set_string_option_global(vimoption_T *opt, char **varp)
/// @param opt_flags OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL.
///
/// TODO(famiu): Remove this and its win/buf variants.
void set_string_option_direct(const char *name, int opt_idx, const char *val, int opt_flags,
int set_sid)
void set_string_option_direct(OptIndex opt_idx, const char *val, int opt_flags, int set_sid)
{
int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
int idx = opt_idx;
if (idx == -1) { // Use name.
idx = findoption(name);
if (idx < 0) { // Not found (should not happen).
internal_error("set_string_option_direct()");
siemsg(_("For option %s"), name);
return;
}
}
vimoption_T *opt = get_option(idx);
vimoption_T *opt = get_option(opt_idx);
if (opt->var == NULL) { // can't set hidden option
return;
@ -314,53 +301,53 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
assert(opt->var != &p_shada);
int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
char *s = xstrdup(val);
{
char **varp = (char **)get_varp_scope(opt, both ? OPT_LOCAL : opt_flags);
if ((opt_flags & OPT_FREE) && (opt->flags & P_ALLOCED)) {
free_string_option(*varp);
}
*varp = s;
char **varp = (char **)get_varp_scope(opt, both ? OPT_LOCAL : opt_flags);
// For buffer/window local option may also set the global value.
if (both) {
set_string_option_global(opt, varp);
}
if ((opt_flags & OPT_FREE) && (opt->flags & P_ALLOCED)) {
free_string_option(*varp);
}
*varp = s;
opt->flags |= P_ALLOCED;
// For buffer/window local option may also set the global value.
if (both) {
set_string_option_global(opt, varp);
}
// When setting both values of a global option with a local value,
// make the local value empty, so that the global value is used.
if ((opt->indir & PV_BOTH) && both) {
free_string_option(*varp);
*varp = empty_string_option;
}
if (set_sid != SID_NONE) {
sctx_T script_ctx;
opt->flags |= P_ALLOCED;
if (set_sid == 0) {
script_ctx = current_sctx;
} else {
script_ctx.sc_sid = set_sid;
script_ctx.sc_seq = 0;
script_ctx.sc_lnum = 0;
}
set_option_sctx_idx(idx, opt_flags, script_ctx);
// When setting both values of a global option with a local value,
// make the local value empty, so that the global value is used.
if ((opt->indir & PV_BOTH) && both) {
free_string_option(*varp);
*varp = empty_string_option;
}
if (set_sid != SID_NONE) {
sctx_T script_ctx;
if (set_sid == 0) {
script_ctx = current_sctx;
} else {
script_ctx.sc_sid = set_sid;
script_ctx.sc_seq = 0;
script_ctx.sc_lnum = 0;
}
set_option_sctx(opt_idx, opt_flags, script_ctx);
}
}
/// Like set_string_option_direct(), but for a window-local option in "wp".
/// Blocks autocommands to avoid the old curwin becoming invalid.
void set_string_option_direct_in_win(win_T *wp, const char *name, int opt_idx, const char *val,
int opt_flags, int set_sid)
void set_string_option_direct_in_win(win_T *wp, OptIndex opt_idx, const char *val, int opt_flags,
int set_sid)
{
win_T *save_curwin = curwin;
block_autocmds();
curwin = wp;
curbuf = curwin->w_buffer;
set_string_option_direct(name, opt_idx, val, opt_flags, set_sid);
set_string_option_direct(opt_idx, val, opt_flags, set_sid);
curwin = save_curwin;
curbuf = curwin->w_buffer;
unblock_autocmds();
@ -368,14 +355,14 @@ void set_string_option_direct_in_win(win_T *wp, const char *name, int opt_idx, c
/// Like set_string_option_direct(), but for a buffer-local option in "buf".
/// Blocks autocommands to avoid the old curwin becoming invalid.
void set_string_option_direct_in_buf(buf_T *buf, const char *name, int opt_idx, const char *val,
int opt_flags, int set_sid)
void set_string_option_direct_in_buf(buf_T *buf, OptIndex opt_idx, const char *val, int opt_flags,
int set_sid)
{
buf_T *save_curbuf = curbuf;
block_autocmds();
curbuf = buf;
set_string_option_direct(name, opt_idx, val, opt_flags, set_sid);
set_string_option_direct(opt_idx, val, opt_flags, set_sid);
curbuf = save_curbuf;
unblock_autocmds();
}

2
src/nvim/path.c
View File

@ -1666,7 +1666,7 @@ static char *eval_includeexpr(const char *const ptr, const size_t len)
current_sctx = curbuf->b_p_script_ctx[BV_INEX].script_ctx;
char *res = eval_to_string_safe(curbuf->b_p_inex,
was_set_insecurely(curwin, "includeexpr", OPT_LOCAL));
was_set_insecurely(curwin, kOptIncludeexpr, OPT_LOCAL));
set_vim_var_string(VV_FNAME, NULL, 0);
current_sctx = save_sctx;

10
src/nvim/popupmenu.c
View File

@ -767,11 +767,11 @@ static bool pum_set_selected(int n, int repeat)
if (res == OK) {
// Edit a new, empty buffer. Set options for a "wipeout"
// buffer.
set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err("bl", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
set_option_value_give_err("diff", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err(kOptBuflisted, BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
set_option_value_give_err(kOptDiff, BOOLEAN_OPTVAL(false), OPT_LOCAL);
}
}

16
src/nvim/quickfix.c
View File

@ -3645,12 +3645,12 @@ static int qf_goto_cwindow(const qf_info_T *qi, bool resize, int sz, bool vertsp
static void qf_set_cwindow_options(void)
{
// switch off 'swapfile'
set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("quickfix"), OPT_LOCAL);
set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("quickfix"), OPT_LOCAL);
set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
RESET_BINDING(curwin);
curwin->w_p_diff = false;
set_option_value_give_err("fdm", STATIC_CSTR_AS_OPTVAL("manual"), OPT_LOCAL);
set_option_value_give_err(kOptFoldmethod, STATIC_CSTR_AS_OPTVAL("manual"), OPT_LOCAL);
}
// Open a new quickfix or location list window, load the quickfix buffer and
@ -4212,7 +4212,7 @@ static void qf_fill_buffer(qf_list_T *qfl, buf_T *buf, qfline_T *old_last, int q
// resembles reading a file into a buffer, it's more logical when using
// autocommands.
curbuf->b_ro_locked++;
set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("qf"), OPT_LOCAL);
set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("qf"), OPT_LOCAL);
curbuf->b_p_ma = false;
keep_filetype = true; // don't detect 'filetype'
@ -5090,7 +5090,7 @@ void ex_cfile(exarg_T *eap)
}
}
if (*eap->arg != NUL) {
set_string_option_direct("ef", -1, eap->arg, OPT_FREE, 0);
set_string_option_direct(kOptErrorfile, eap->arg, OPT_FREE, 0);
}
char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
@ -7220,7 +7220,7 @@ void ex_helpgrep(exarg_T *eap)
bool updated = false;
// Make 'cpoptions' empty, the 'l' flag should not be used here.
char *const save_cpo = p_cpo;
const bool save_cpo_allocated = is_option_allocated("cpo");
const bool save_cpo_allocated = (get_option(kOptCpoptions)->flags & P_ALLOCED);
p_cpo = empty_string_option;
bool new_qi = false;
@ -7258,7 +7258,7 @@ void ex_helpgrep(exarg_T *eap)
// Darn, some plugin changed the value. If it's still empty it was
// changed and restored, need to restore in the complicated way.
if (*p_cpo == NUL) {
set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
}
if (save_cpo_allocated) {
free_string_option(save_cpo);

2
src/nvim/runtime.c
View File

@ -1061,7 +1061,7 @@ static int add_pack_dir_to_rtp(char *fname, bool is_pack)
xstrlcat(new_rtp, afterdir, new_rtp_capacity);
}
set_option_value_give_err("rtp", CSTR_AS_OPTVAL(new_rtp), 0);
set_option_value_give_err(kOptRuntimepath, CSTR_AS_OPTVAL(new_rtp), 0);
xfree(new_rtp);
retval = OK;

6
src/nvim/spell.c
View File

@ -3218,14 +3218,14 @@ void ex_spelldump(exarg_T *eap)
if (no_spell_checking(curwin)) {
return;
}
OptVal spl = get_option_value(findoption("spl"), OPT_LOCAL);
OptVal spl = get_option_value(kOptSpelllang, OPT_LOCAL);
// Create a new empty buffer in a new window.
do_cmdline_cmd("new");
// enable spelling locally in the new window
set_option_value_give_err("spell", BOOLEAN_OPTVAL(true), OPT_LOCAL);
set_option_value_give_err("spl", spl, OPT_LOCAL);
set_option_value_give_err(kOptSpell, BOOLEAN_OPTVAL(true), OPT_LOCAL);
set_option_value_give_err(kOptSpelllang, spl, OPT_LOCAL);
optval_free(spl);
if (!buf_is_empty(curbuf)) {

2
src/nvim/spellfile.c
View File

@ -5600,7 +5600,7 @@ static void init_spellfile(void)
&& strstr(path_tail(fname), ".ascii.") != NULL)
? "ascii"
: spell_enc()));
set_option_value_give_err("spellfile", CSTR_AS_OPTVAL(buf), OPT_LOCAL);
set_option_value_give_err(kOptSpellfile, CSTR_AS_OPTVAL(buf), OPT_LOCAL);
break;
}
aspath = false;

38
src/nvim/statusline.c
View File

@ -296,7 +296,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
char buf[MAXPATHL];
char transbuf[MAXPATHL];
char *stl;
char *opt_name;
OptIndex opt_idx = kOptInvalid;
int opt_scope = 0;
stl_hlrec_t *hltab;
StlClickRecord *tabtab;
@ -320,9 +320,9 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
fillchar = ' ';
attr = HL_ATTR(HLF_TPF);
maxwidth = Columns;
opt_name = "tabline";
opt_idx = kOptTabline;
} else if (draw_winbar) {
opt_name = "winbar";
opt_idx = kOptWinbar;
stl = ((*wp->w_p_wbr != NUL) ? wp->w_p_wbr : p_wbr);
opt_scope = ((*wp->w_p_wbr != NUL) ? OPT_LOCAL : 0);
row = -1; // row zero is first row of text
@ -351,7 +351,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
if (draw_ruler) {
stl = p_ruf;
opt_name = "rulerformat";
opt_idx = kOptRulerformat;
// advance past any leading group spec - implicit in ru_col
if (*stl == '%') {
if (*++stl == '-') {
@ -379,7 +379,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
attr = HL_ATTR(HLF_MSG);
}
} else {
opt_name = "statusline";
opt_idx = kOptStatusline;
stl = ((*wp->w_p_stl != NUL) ? wp->w_p_stl : p_stl);
opt_scope = ((*wp->w_p_stl != NUL) ? OPT_LOCAL : 0);
}
@ -402,7 +402,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
// Make a copy, because the statusline may include a function call that
// might change the option value and free the memory.
stl = xstrdup(stl);
build_stl_str_hl(ewp, buf, sizeof(buf), stl, opt_name, opt_scope,
build_stl_str_hl(ewp, buf, sizeof(buf), stl, opt_idx, opt_scope,
fillchar, maxwidth, &hltab, &tabtab, NULL);
xfree(stl);
@ -881,7 +881,7 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
StlClickRecord *clickrec;
char *stc = xstrdup(wp->w_p_stc);
int width = build_stl_str_hl(wp, stcp->text, MAXPATHL, stc, "statuscolumn", OPT_LOCAL, ' ',
int width = build_stl_str_hl(wp, stcp->text, MAXPATHL, stc, kOptStatuscolumn, OPT_LOCAL, ' ',
stcp->width, &stcp->hlrec, fillclick ? &clickrec : NULL, stcp);
xfree(stc);
@ -913,8 +913,8 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
/// Note: This should not be NameBuff
/// @param outlen The length of the output buffer
/// @param fmt The statusline format string
/// @param opt_name The option name corresponding to "fmt"
/// @param opt_scope The scope corresponding to "opt_name"
/// @param opt_idx Index of the option corresponding to "fmt"
/// @param opt_scope The scope corresponding to "opt_idx"
/// @param fillchar Character to use when filling empty space in the statusline
/// @param maxwidth The maximum width to make the statusline
/// @param hltab HL attributes (can be NULL)
@ -922,9 +922,9 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
/// @param stcp Status column attributes (can be NULL)
///
/// @return The final width of the statusline
int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_name, int opt_scope,
int fillchar, int maxwidth, stl_hlrec_t **hltab, StlClickRecord **tabtab,
statuscol_T *stcp)
int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, OptIndex opt_idx,
int opt_scope, int fillchar, int maxwidth, stl_hlrec_t **hltab,
StlClickRecord **tabtab, statuscol_T *stcp)
{
static size_t stl_items_len = 20; // Initial value, grows as needed.
static stl_item_t *stl_items = NULL;
@ -957,10 +957,10 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
stl_separator_locations = xmalloc(sizeof(int) * stl_items_len);
}
// if "fmt" was set insecurely it needs to be evaluated in the sandbox
// "opt_name" will be NULL when caller is nvim_eval_statusline()
const int use_sandbox = opt_name ? was_set_insecurely(wp, opt_name, opt_scope)
: false;
// If "fmt" was set insecurely it needs to be evaluated in the sandbox.
// "opt_idx" will be kOptInvalid when caller is nvim_eval_statusline().
const int use_sandbox = (opt_idx != kOptInvalid) ? was_set_insecurely(wp, opt_idx, opt_scope)
: false;
// When the format starts with "%!" then evaluate it as an expression and
// use the result as the actual format string.
@ -1545,7 +1545,7 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
break;
case STL_SHOWCMD:
if (p_sc && (opt_name == NULL || strcmp(opt_name, p_sloc) == 0)) {
if (p_sc && (opt_idx == kOptInvalid || findoption(p_sloc) == opt_idx)) {
str = showcmd_buf;
}
break;
@ -2177,8 +2177,8 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
// TODO(Bram): find out why using called_emsg_before makes tests fail, does it
// matter?
// if (called_emsg > called_emsg_before)
if (opt_name && did_emsg > did_emsg_before) {
set_string_option_direct(opt_name, -1, "", OPT_FREE | opt_scope, SID_ERROR);
if (opt_idx != kOptInvalid && did_emsg > did_emsg_before) {
set_string_option_direct(opt_idx, "", OPT_FREE | opt_scope, SID_ERROR);
}
// A user function may reset KeyTyped, restore it.

1
src/nvim/statusline.h
View File

@ -4,6 +4,7 @@
#include "nvim/buffer_defs.h" // IWYU pragma: keep
#include "nvim/macros_defs.h"
#include "nvim/option_defs.h"
#include "nvim/statusline_defs.h" // IWYU pragma: export
/// Array defining what should be done when tabline is clicked

6
src/nvim/terminal.c
View File

@ -233,7 +233,7 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts)
aucmd_prepbuf(&aco, buf);
refresh_screen(rv, buf);
set_option_value("buftype", STATIC_CSTR_AS_OPTVAL("terminal"), OPT_LOCAL);
set_option_value(kOptBuftype, STATIC_CSTR_AS_OPTVAL("terminal"), OPT_LOCAL);
// Default settings for terminal buffers
buf->b_p_ma = false; // 'nomodifiable'
@ -241,8 +241,8 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts)
buf->b_p_scbk = // 'scrollback' (initialize local from global)
(p_scbk < 0) ? 10000 : MAX(1, p_scbk);
buf->b_p_tw = 0; // 'textwidth'
set_option_value("wrap", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value("list", BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value(kOptWrap, BOOLEAN_OPTVAL(false), OPT_LOCAL);
set_option_value(kOptList, BOOLEAN_OPTVAL(false), OPT_LOCAL);
if (buf->b_ffname != NULL) {
buf_set_term_title(buf, buf->b_ffname, strlen(buf->b_ffname));
}

2
src/nvim/textformat.c
View File

@ -870,7 +870,7 @@ void op_formatexpr(oparg_T *oap)
/// @param c character to be inserted
int fex_format(linenr_T lnum, long count, int c)
{
int use_sandbox = was_set_insecurely(curwin, "formatexpr", OPT_LOCAL);
int use_sandbox = was_set_insecurely(curwin, kOptFormatexpr, OPT_LOCAL);
const sctx_T save_sctx = current_sctx;
// Set v:lnum to the first line number and v:count to the number of lines.

2
src/nvim/ui.c
View File

@ -235,7 +235,7 @@ void ui_refresh(void)
p_lz = save_p_lz;
if (ext_widgets[kUIMessages]) {
set_option_value("cmdheight", NUMBER_OPTVAL(0), 0);
set_option_value(kOptCmdheight, NUMBER_OPTVAL(0), 0);
command_height();
}
ui_mode_info_set();

2
src/nvim/window.c
View File

@ -5183,7 +5183,7 @@ void win_new_screensize(void)
if (old_Rows != Rows) {
// If 'window' uses the whole screen, keep it using that.
// Don't change it when set with "-w size" on the command line.
if (p_window == old_Rows - 1 || (old_Rows == 0 && !option_was_set("window"))) {
if (p_window == old_Rows - 1 || (old_Rows == 0 && !option_was_set(kOptWindow))) {
p_window = Rows - 1;
}
old_Rows = Rows;

4
test/functional/lua/ffi_spec.lua
View File

@ -38,7 +38,7 @@ describe('ffi.cdef', function()
char *out,
size_t outlen,
char *fmt,
char *opt_name,
int opt_idx,
int opt_scope,
int fillchar,
int maxwidth,
@ -53,7 +53,7 @@ describe('ffi.cdef', function()
ffi.new('char[1024]'),
1024,
ffi.cast('char*', 'StatusLineOfLength20'),
nil,
-1,
0,
0,
0,

2
test/unit/statusline_spec.lua
View File

@ -33,7 +33,7 @@ describe('build_stl_str_hl', function()
output_buffer,
buffer_byte_size,
to_cstr(pat),
NULL,
-1,
0,
fillchar,
maximum_cell_count,