IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge #6513 from ZyX-I/lazier-arg_errmsg-gettext

Browse Source
This commit is contained in:
Justin M. Keyes 2017-04-23 01:02:39 +02:00 committed by GitHub
commit a9d37c928e
5 changed files with 143 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
src/nvim/eval.c
View File

@ -2382,9 +2382,9 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv,
&tv, &di, true, false) == OK) { &tv, &di, true, false) == OK) {
if ((di == NULL if ((di == NULL
|| (!var_check_ro(di->di_flags, (const char *)lp->ll_name, || (!var_check_ro(di->di_flags, (const char *)lp->ll_name,
STRLEN(lp->ll_name)) TV_CSTRING)
&& !tv_check_lock(di->di_tv.v_lock, (const char *)lp->ll_name, && !tv_check_lock(di->di_tv.v_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name)))) TV_CSTRING)))
&& eexe_mod_op(&tv, rettv, (const char *)op) == OK) { && eexe_mod_op(&tv, rettv, (const char *)op) == OK) {
set_var(lp->ll_name, lp->ll_name_len, &tv, false); set_var(lp->ll_name, lp->ll_name_len, &tv, false);
} }
@ -2397,7 +2397,7 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv,
} else if (tv_check_lock(lp->ll_newkey == NULL } else if (tv_check_lock(lp->ll_newkey == NULL
? lp->ll_tv->v_lock ? lp->ll_tv->v_lock
: lp->ll_tv->vval.v_dict->dv_lock, : lp->ll_tv->vval.v_dict->dv_lock,
(const char *)lp->ll_name, STRLEN(lp->ll_name))) { (const char *)lp->ll_name, TV_CSTRING)) {
} else if (lp->ll_range) { } else if (lp->ll_range) {
listitem_T *ll_li = lp->ll_li; listitem_T *ll_li = lp->ll_li;
int ll_n1 = lp->ll_n1; int ll_n1 = lp->ll_n1;
@ -2406,7 +2406,7 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv,
for (listitem_T *ri = rettv->vval.v_list->lv_first; for (listitem_T *ri = rettv->vval.v_list->lv_first;
ri != NULL && ll_li != NULL; ) { ri != NULL && ll_li != NULL; ) {
if (tv_check_lock(ll_li->li_tv.v_lock, (const char *)lp->ll_name, if (tv_check_lock(ll_li->li_tv.v_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name))) { TV_CSTRING)) {
return; return;
} }
ri = ri->li_next; ri = ri->li_next;
@ -2997,13 +2997,13 @@ int do_unlet(const char *const name, const size_t name_len, const int forceit)
} }
if (hi != NULL && !HASHITEM_EMPTY(hi)) { if (hi != NULL && !HASHITEM_EMPTY(hi)) {
dictitem_T *const di = TV_DICT_HI2DI(hi); dictitem_T *const di = TV_DICT_HI2DI(hi);
if (var_check_fixed(di->di_flags, (const char *)name, STRLEN(name)) if (var_check_fixed(di->di_flags, (const char *)name, TV_CSTRING)
|| var_check_ro(di->di_flags, (const char *)name, STRLEN(name)) || var_check_ro(di->di_flags, (const char *)name, TV_CSTRING)
|| tv_check_lock(d->dv_lock, (const char *)name, STRLEN(name))) { || tv_check_lock(d->dv_lock, (const char *)name, TV_CSTRING)) {
return FAIL; return FAIL;
} }
if (tv_check_lock(d->dv_lock, (const char *)name, STRLEN(name))) { if (tv_check_lock(d->dv_lock, (const char *)name, TV_CSTRING)) {
return FAIL; return FAIL;
} }
@ -6557,10 +6557,8 @@ static void f_add(typval_T *argvars, typval_T *rettv, FunPtr fptr)
rettv->vval.v_number = 1; /* Default: Failed */ rettv->vval.v_number = 1; /* Default: Failed */
if (argvars[0].v_type == VAR_LIST) { if (argvars[0].v_type == VAR_LIST) {
const char *const arg_errmsg = _("add() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
if ((l = argvars[0].vval.v_list) != NULL if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) { && !tv_check_lock(l->lv_lock, "add() argument", TV_TRANSLATE)) {
tv_list_append_tv(l, &argvars[1]); tv_list_append_tv(l, &argvars[1]);
tv_copy(&argvars[0], rettv); tv_copy(&argvars[0], rettv);
} }
@ -8152,7 +8150,6 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr) static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{ {
const char *const arg_errmsg = N_("extend() argument"); const char *const arg_errmsg = N_("extend() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST) { if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST) {
long before; long before;
@ -8161,13 +8158,13 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
list_T *const l1 = argvars[0].vval.v_list; list_T *const l1 = argvars[0].vval.v_list;
list_T *const l2 = argvars[1].vval.v_list; list_T *const l2 = argvars[1].vval.v_list;
if (l1 == NULL) { if (l1 == NULL) {
const bool locked = tv_check_lock(VAR_FIXED, arg_errmsg, arg_errmsg_len); const bool locked = tv_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
(void)locked; (void)locked;
assert(locked == true); assert(locked == true);
} else if (l2 == NULL) { } else if (l2 == NULL) {
// Do nothing // Do nothing
tv_copy(&argvars[0], rettv); tv_copy(&argvars[0], rettv);
} else if (!tv_check_lock(l1->lv_lock, arg_errmsg, arg_errmsg_len)) { } else if (!tv_check_lock(l1->lv_lock, arg_errmsg, TV_TRANSLATE)) {
listitem_T *item; listitem_T *item;
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
before = tv_get_number_chk(&argvars[2], &error); before = tv_get_number_chk(&argvars[2], &error);
@ -8195,13 +8192,13 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
dict_T *const d1 = argvars[0].vval.v_dict; dict_T *const d1 = argvars[0].vval.v_dict;
dict_T *const d2 = argvars[1].vval.v_dict; dict_T *const d2 = argvars[1].vval.v_dict;
if (d1 == NULL) { if (d1 == NULL) {
const bool locked = tv_check_lock(VAR_FIXED, arg_errmsg, arg_errmsg_len); const bool locked = tv_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
(void)locked; (void)locked;
assert(locked == true); assert(locked == true);
} else if (d2 == NULL) { } else if (d2 == NULL) {
// Do nothing // Do nothing
tv_copy(&argvars[0], rettv); tv_copy(&argvars[0], rettv);
} else if (!tv_check_lock(d1->dv_lock, arg_errmsg, arg_errmsg_len)) { } else if (!tv_check_lock(d1->dv_lock, arg_errmsg, TV_TRANSLATE)) {
const char *action = "force"; const char *action = "force";
// Check the third argument. // Check the third argument.
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
@ -8349,20 +8346,19 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
int todo; int todo;
char_u *ermsg = (char_u *)(map ? "map()" : "filter()"); char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
const char *const arg_errmsg = (map const char *const arg_errmsg = (map
? _("map() argument") ? N_("map() argument")
: _("filter() argument")); : N_("filter() argument"));
const size_t arg_errmsg_len = strlen(arg_errmsg);
int save_did_emsg; int save_did_emsg;
int idx = 0; int idx = 0;
if (argvars[0].v_type == VAR_LIST) { if (argvars[0].v_type == VAR_LIST) {
if ((l = argvars[0].vval.v_list) == NULL if ((l = argvars[0].vval.v_list) == NULL
|| (!map && tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len))) { || (!map && tv_check_lock(l->lv_lock, arg_errmsg, TV_TRANSLATE))) {
return; return;
} }
} else if (argvars[0].v_type == VAR_DICT) { } else if (argvars[0].v_type == VAR_DICT) {
if ((d = argvars[0].vval.v_dict) == NULL if ((d = argvars[0].vval.v_dict) == NULL
|| (!map && tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len))) { || (!map && tv_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
return; return;
} }
} else { } else {
@ -8395,8 +8391,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
di = TV_DICT_HI2DI(hi); di = TV_DICT_HI2DI(hi);
if (map if (map
&& (tv_check_lock(di->di_tv.v_lock, arg_errmsg, arg_errmsg_len) && (tv_check_lock(di->di_tv.v_lock, arg_errmsg, TV_TRANSLATE)
|| var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len))) { || var_check_ro(di->di_flags, arg_errmsg, TV_TRANSLATE))) {
break; break;
} }
@ -8407,8 +8403,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
break; break;
} }
if (!map && rem) { if (!map && rem) {
if (var_check_fixed(di->di_flags, arg_errmsg, arg_errmsg_len) if (var_check_fixed(di->di_flags, arg_errmsg, TV_TRANSLATE)
|| var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) { || var_check_ro(di->di_flags, arg_errmsg, TV_TRANSLATE)) {
break; break;
} }
tv_dict_item_remove(d, di); tv_dict_item_remove(d, di);
@ -8421,7 +8417,7 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
for (li = l->lv_first; li != NULL; li = nli) { for (li = l->lv_first; li != NULL; li = nli) {
if (map if (map
&& tv_check_lock(li->li_tv.v_lock, arg_errmsg, arg_errmsg_len)) { && tv_check_lock(li->li_tv.v_lock, arg_errmsg, TV_TRANSLATE)) {
break; break;
} }
nli = li->li_next; nli = li->li_next;
@ -11154,13 +11150,12 @@ static void f_insert(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{ {
list_T *l; list_T *l;
bool error = false; bool error = false;
const char *const arg_errmsg = _("insert() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type != VAR_LIST) { if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listarg), "insert()"); EMSG2(_(e_listarg), "insert()");
} else if ((l = argvars[0].vval.v_list) != NULL } else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) { && !tv_check_lock(l->lv_lock, N_("insert() argument"),
TV_TRANSLATE)) {
long before = 0; long before = 0;
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
before = tv_get_number_chk(&argvars[2], &error); before = tv_get_number_chk(&argvars[2], &error);
@ -13208,21 +13203,20 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
long end; long end;
dict_T *d; dict_T *d;
dictitem_T *di; dictitem_T *di;
const char *const arg_errmsg = _("remove() argument"); const char *const arg_errmsg = N_("remove() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type == VAR_DICT) { if (argvars[0].v_type == VAR_DICT) {
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
EMSG2(_(e_toomanyarg), "remove()"); EMSG2(_(e_toomanyarg), "remove()");
} else if ((d = argvars[0].vval.v_dict) != NULL } else if ((d = argvars[0].vval.v_dict) != NULL
&& !tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len)) { && !tv_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE)) {
const char *key = tv_get_string_chk(&argvars[1]); const char *key = tv_get_string_chk(&argvars[1]);
if (key != NULL) { if (key != NULL) {
di = tv_dict_find(d, key, -1); di = tv_dict_find(d, key, -1);
if (di == NULL) { if (di == NULL) {
EMSG2(_(e_dictkey), key); EMSG2(_(e_dictkey), key);
} else if (!var_check_fixed(di->di_flags, arg_errmsg, arg_errmsg_len) } else if (!var_check_fixed(di->di_flags, arg_errmsg, TV_TRANSLATE)
&& !var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) { && !var_check_ro(di->di_flags, arg_errmsg, TV_TRANSLATE)) {
*rettv = di->di_tv; *rettv = di->di_tv;
di->di_tv = TV_INITIAL_VALUE; di->di_tv = TV_INITIAL_VALUE;
tv_dict_item_remove(d, di); tv_dict_item_remove(d, di);
@ -13235,7 +13229,7 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
} else if (argvars[0].v_type != VAR_LIST) { } else if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listdictarg), "remove()"); EMSG2(_(e_listdictarg), "remove()");
} else if ((l = argvars[0].vval.v_list) != NULL } else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) { && !tv_check_lock(l->lv_lock, arg_errmsg, TV_TRANSLATE)) {
bool error = false; bool error = false;
idx = tv_get_number_chk(&argvars[1], &error); idx = tv_get_number_chk(&argvars[1], &error);
@ -13506,14 +13500,12 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, FunPtr fptr)
*/ */
static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr) static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{ {
const char *const arg_errmsg = _("reverse() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
list_T *l; list_T *l;
if (argvars[0].v_type != VAR_LIST) { if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listarg), "reverse()"); EMSG2(_(e_listarg), "reverse()");
} else if ((l = argvars[0].vval.v_list) != NULL } else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) { && !tv_check_lock(l->lv_lock, N_("reverse() argument"),
TV_TRANSLATE)) {
listitem_T *li = l->lv_last; listitem_T *li = l->lv_last;
l->lv_first = l->lv_last = NULL; l->lv_first = l->lv_last = NULL;
l->lv_len = 0; l->lv_len = 0;
@ -15205,16 +15197,14 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
sortinfo = &info; sortinfo = &info;
const char *const arg_errmsg = (sort const char *const arg_errmsg = (sort
? _("sort() argument") ? N_("sort() argument")
: _("uniq() argument")); : N_("uniq() argument"));
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type != VAR_LIST) { if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listarg), sort ? "sort()" : "uniq()"); EMSG2(_(e_listarg), sort ? "sort()" : "uniq()");
} else { } else {
l = argvars[0].vval.v_list; l = argvars[0].vval.v_list;
if (l == NULL if (l == NULL || tv_check_lock(l->lv_lock, arg_errmsg, TV_TRANSLATE)) {
|| tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
goto theend; goto theend;
} }
rettv->vval.v_list = l; rettv->vval.v_list = l;
@ -18961,24 +18951,43 @@ static void set_var(const char *name, const size_t name_len, typval_T *const tv,
/// ///
/// @param[in] flags di_flags attribute value. /// @param[in] flags di_flags attribute value.
/// @param[in] name Variable name, for use in error message. /// @param[in] name Variable name, for use in error message.
/// @param[in] name_len Variable name length. /// @param[in] name_len Variable name length. Use #TV_TRANSLATE to translate
/// variable name and compute the length. Use #TV_CSTRING
/// to compute the length with strlen() without
/// translating.
///
/// Both #TV_… values are used for optimization purposes:
/// variable name with its length is needed only in case
/// of error, when no error occurs computing them is
/// a waste of CPU resources. This especially applies to
/// gettext.
/// ///
/// @return True if variable is read-only: either always or in sandbox when /// @return True if variable is read-only: either always or in sandbox when
/// sandbox is enabled, false otherwise. /// sandbox is enabled, false otherwise.
bool var_check_ro(const int flags, const char *const name, bool var_check_ro(const int flags, const char *name,
const size_t name_len) size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{ {
const char *error_message = NULL;
if (flags & DI_FLAGS_RO) { if (flags & DI_FLAGS_RO) {
emsgf(_(e_readonlyvar), (int)name_len, name); error_message = N_(e_readonlyvar);
return true; } else if ((flags & DI_FLAGS_RO_SBX) && sandbox) {
error_message = N_("E794: Cannot set variable in the sandbox: \"%.*s\"");
} }
if ((flags & DI_FLAGS_RO_SBX) && sandbox) {
emsgf(_("E794: Cannot set variable in the sandbox: \"%.*s\""), if (error_message == NULL) {
(int)name_len, name); return false;
return true;
} }
return false; if (name_len == TV_TRANSLATE) {
name = _(name);
name_len = strlen(name);
} else if (name_len == TV_CSTRING) {
name_len = strlen(name);
}
emsgf(_(error_message), (int)name_len, name);
return true;
} }
/// Check whether variable is fixed (DI_FLAGS_FIX) /// Check whether variable is fixed (DI_FLAGS_FIX)
@ -18987,14 +18996,29 @@ bool var_check_ro(const int flags, const char *const name,
/// ///
/// @param[in] flags di_flags attribute value. /// @param[in] flags di_flags attribute value.
/// @param[in] name Variable name, for use in error message. /// @param[in] name Variable name, for use in error message.
/// @param[in] name_len Variable name length. /// @param[in] name_len Variable name length. Use #TV_TRANSLATE to translate
/// variable name and compute the length. Use #TV_CSTRING
/// to compute the length with strlen() without
/// translating.
///
/// Both #TV_… values are used for optimization purposes:
/// variable name with its length is needed only in case
/// of error, when no error occurs computing them is
/// a waste of CPU resources. This especially applies to
/// gettext.
/// ///
/// @return True if variable is fixed, false otherwise. /// @return True if variable is fixed, false otherwise.
static bool var_check_fixed(const int flags, const char *const name, static bool var_check_fixed(const int flags, const char *name,
const size_t name_len) size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{ {
if (flags & DI_FLAGS_FIX) { if (flags & DI_FLAGS_FIX) {
if (name_len == TV_TRANSLATE) {
name = _(name);
name_len = strlen(name);
} else if (name_len == TV_CSTRING) {
name_len = strlen(name);
}
emsgf(_("E795: Cannot delete variable %.*s"), (int)name_len, name); emsgf(_("E795: Cannot delete variable %.*s"), (int)name_len, name);
return true; return true;
} }
@ -19802,12 +19826,12 @@ void ex_function(exarg_T *eap)
} }
if (fudi.fd_di == NULL) { if (fudi.fd_di == NULL) {
if (tv_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg, if (tv_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
STRLEN(eap->arg))) { TV_CSTRING)) {
// Can't add a function to a locked dictionary // Can't add a function to a locked dictionary
goto erret; goto erret;
} }
} else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg, } else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg,
STRLEN(eap->arg))) { TV_CSTRING)) {
// Can't change an existing function if it is locked // Can't change an existing function if it is locked
goto erret; goto erret;
} }

13
src/nvim/eval/encode.c
View File

@ -182,9 +182,9 @@ static int conv_error(const char *const msg, const MPConvStack *const mpstack,
} }
} }
} }
EMSG3(msg, objname, (kv_size(*mpstack) == 0 emsgf(msg, _(objname), (kv_size(*mpstack) == 0
? _("itself") ? _("itself")
: (char *) msg_ga.ga_data)); : (char *)msg_ga.ga_data));
ga_clear(&msg_ga); ga_clear(&msg_ga);
return FAIL; return FAIL;
} }
@ -793,7 +793,7 @@ char *encode_tv2string(typval_T *tv, size_t *len)
garray_T ga; garray_T ga;
ga_init(&ga, (int)sizeof(char), 80); ga_init(&ga, (int)sizeof(char), 80);
const int evs_ret = encode_vim_to_string(&ga, tv, const int evs_ret = encode_vim_to_string(&ga, tv,
"encode_tv2string() argument"); N_("encode_tv2string() argument"));
(void)evs_ret; (void)evs_ret;
assert(evs_ret == OK); assert(evs_ret == OK);
did_echo_string_emsg = false; did_echo_string_emsg = false;
@ -821,7 +821,7 @@ char *encode_tv2echo(typval_T *tv, size_t *len)
ga_concat(&ga, tv->vval.v_string); ga_concat(&ga, tv->vval.v_string);
} }
} else { } else {
const int eve_ret = encode_vim_to_echo(&ga, tv, ":echo argument"); const int eve_ret = encode_vim_to_echo(&ga, tv, N_(":echo argument"));
(void)eve_ret; (void)eve_ret;
assert(eve_ret == OK); assert(eve_ret == OK);
} }
@ -844,7 +844,8 @@ char *encode_tv2json(typval_T *tv, size_t *len)
{ {
garray_T ga; garray_T ga;
ga_init(&ga, (int)sizeof(char), 80); ga_init(&ga, (int)sizeof(char), 80);
const int evj_ret = encode_vim_to_json(&ga, tv, "encode_tv2json() argument"); const int evj_ret = encode_vim_to_json(&ga, tv,
N_("encode_tv2json() argument"));
if (!evj_ret) { if (!evj_ret) {
ga_clear(&ga); ga_clear(&ga);
} }

42
src/nvim/eval/typval.c
View File

@ -1801,11 +1801,13 @@ static inline void _nothing_conv_dict_end(typval_T *const tv,
#define TYPVAL_ENCODE_NAME nothing #define TYPVAL_ENCODE_NAME nothing
#define TYPVAL_ENCODE_FIRST_ARG_TYPE const void *const #define TYPVAL_ENCODE_FIRST_ARG_TYPE const void *const
#define TYPVAL_ENCODE_FIRST_ARG_NAME ignored #define TYPVAL_ENCODE_FIRST_ARG_NAME ignored
#define TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME
#include "nvim/eval/typval_encode.c.h" #include "nvim/eval/typval_encode.c.h"
#undef TYPVAL_ENCODE_SCOPE #undef TYPVAL_ENCODE_SCOPE
#undef TYPVAL_ENCODE_NAME #undef TYPVAL_ENCODE_NAME
#undef TYPVAL_ENCODE_FIRST_ARG_TYPE #undef TYPVAL_ENCODE_FIRST_ARG_TYPE
#undef TYPVAL_ENCODE_FIRST_ARG_NAME #undef TYPVAL_ENCODE_FIRST_ARG_NAME
#undef TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME
#undef TYPVAL_ENCODE_ALLOW_SPECIALS #undef TYPVAL_ENCODE_ALLOW_SPECIALS
#undef TYPVAL_ENCODE_CONV_NIL #undef TYPVAL_ENCODE_CONV_NIL
@ -1839,12 +1841,14 @@ static inline void _nothing_conv_dict_end(typval_T *const tv,
/// @param[in,out] tv Value to free. /// @param[in,out] tv Value to free.
void tv_clear(typval_T *const tv) void tv_clear(typval_T *const tv)
{ {
static char *objname = NULL; // cached because gettext() is slow. #6437
if (objname == NULL) {
objname = xstrdup(_("tv_clear() argument"));
}
if (tv != NULL && tv->v_type != VAR_UNKNOWN) { if (tv != NULL && tv->v_type != VAR_UNKNOWN) {
const int evn_ret = encode_vim_to_nothing(NULL, tv, objname); // WARNING: do not translate the string here, gettext is slow and function
// is used *very* often. At the current state encode_vim_to_nothing() does
// not error out and does not use the argument anywhere.
//
// If situation changes and this argument will be used, translate it in the
// place where it is used.
const int evn_ret = encode_vim_to_nothing(NULL, tv, "tv_clear() argument");
(void)evn_ret; (void)evn_ret;
assert(evn_ret == OK); assert(evn_ret == OK);
} }
@ -2047,11 +2051,20 @@ bool tv_islocked(const typval_T *const tv)
/// ///
/// @param[in] lock Lock status. /// @param[in] lock Lock status.
/// @param[in] name Variable name, used in the error message. /// @param[in] name Variable name, used in the error message.
/// @param[in] name_len Variable name length. /// @param[in] name_len Variable name length. Use #TV_TRANSLATE to translate
/// variable name and compute the length. Use #TV_CSTRING
/// to compute the length with strlen() without
/// translating.
///
/// Both #TV_… values are used for optimization purposes:
/// variable name with its length is needed only in case
/// of error, when no error occurs computing them is
/// a waste of CPU resources. This especially applies to
/// gettext.
/// ///
/// @return true if variable is locked, false otherwise. /// @return true if variable is locked, false otherwise.
bool tv_check_lock(const VarLockStatus lock, const char *const name, bool tv_check_lock(const VarLockStatus lock, const char *name,
const size_t name_len) size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_WARN_UNUSED_RESULT
{ {
const char *error_message = NULL; const char *error_message = NULL;
@ -2070,10 +2083,17 @@ bool tv_check_lock(const VarLockStatus lock, const char *const name,
} }
assert(error_message != NULL); assert(error_message != NULL);
const char *const unknown_name = _("Unknown"); if (name == NULL) {
name = _("Unknown");
name_len = strlen(name);
} else if (name_len == TV_TRANSLATE) {
name = _(name);
name_len = strlen(name);
} else if (name_len == TV_CSTRING) {
name_len = strlen(name);
}
emsgf(_(error_message), (name != NULL ? name_len : strlen(unknown_name)), emsgf(_(error_message), (int)name_len, name);
(name != NULL ? name : unknown_name));
return true; return true;
} }

18
src/nvim/eval/typval.h
View File

@ -17,6 +17,7 @@
#include "nvim/pos.h" // for linenr_T #include "nvim/pos.h" // for linenr_T
#include "nvim/gettext.h" #include "nvim/gettext.h"
#include "nvim/message.h" #include "nvim/message.h"
#include "nvim/macros.h"
/// Type used for VimL VAR_NUMBER values /// Type used for VimL VAR_NUMBER values
typedef int varnumber_T; typedef int varnumber_T;
@ -423,6 +424,23 @@ static inline bool tv_is_func(const typval_T tv)
return tv.v_type == VAR_FUNC || tv.v_type == VAR_PARTIAL; return tv.v_type == VAR_FUNC || tv.v_type == VAR_PARTIAL;
} }
/// Specify that argument needs to be translated
///
/// Used for size_t length arguments to avoid calling gettext() and strlen()
/// unless needed.
#define TV_TRANSLATE (SIZE_MAX)
/// Specify that argument is a NUL-terminated C string
///
/// Used for size_t length arguments to avoid calling strlen() unless needed.
#define TV_CSTRING (SIZE_MAX - 1)
#ifdef UNIT_TESTING
// Do not use enum constants, see commit message.
EXTERN const size_t kTVCstring INIT(= TV_CSTRING);
EXTERN const size_t kTVTranslate INIT(= TV_TRANSLATE);
#endif
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
# include "eval/typval.h.generated.h" # include "eval/typval.h.generated.h"
#endif #endif

4
test/unit/eval/typval_spec.lua
View File

@ -2450,6 +2450,10 @@ describe('typval.c', function()
'E741: Value is locked: Unknown')) 'E741: Value is locked: Unknown'))
eq(true, tv_check_lock(lib.VAR_FIXED, nil, 0, eq(true, tv_check_lock(lib.VAR_FIXED, nil, 0,
'E742: Cannot change value of Unknown')) 'E742: Cannot change value of Unknown'))
eq(true, tv_check_lock(lib.VAR_LOCKED, nil, lib.kTVCstring,
'E741: Value is locked: Unknown'))
eq(true, tv_check_lock(lib.VAR_FIXED, 'test', lib.kTVCstring,
'E742: Cannot change value of test'))
end) end)
end) end)
describe('equal()', function() describe('equal()', function()