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 pull request #4178 from watiko/vim-7.4.708

Browse Source 
vim-patch:7.4.{708,717}
This commit is contained in:
Justin M. Keyes 2016-02-09 02:10:57 -05:00
commit 7c2b2ea9c9
4 changed files with 155 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
src/nvim/eval.c
View File

@ -1700,12 +1700,13 @@ static char_u *list_arg_vars(exarg_T *eap, char_u *arg, int *first)
} }
error = TRUE; error = TRUE;
} else { } else {
if (tofree != NULL) if (tofree != NULL) {
name = tofree; name = tofree;
if (get_var_tv(name, len, &tv, TRUE, FALSE) == FAIL) }
error = TRUE; if (get_var_tv(name, len, &tv, NULL, true, false) == FAIL) {
else { error = true;
/* handle d.key, l[idx], f(expr) */ } else {
// handle d.key, l[idx], f(expr)
arg_subsc = arg; arg_subsc = arg;
if (handle_subscript(&arg, &tv, TRUE, TRUE) == FAIL) if (handle_subscript(&arg, &tv, TRUE, TRUE) == FAIL)
error = TRUE; error = TRUE;
@ -2176,10 +2177,10 @@ get_lval (
if (len == -1) if (len == -1)
clear_tv(&var1); clear_tv(&var1);
break; break;
} } else if (var_check_ro(lp->ll_di->di_flags, name, false)) {
/* existing variable, need to check if it can be changed */ // existing variable, need to check if it can be changed
else if (var_check_ro(lp->ll_di->di_flags, name))
return NULL; return NULL;
}
if (len == -1) if (len == -1)
clear_tv(&var1); clear_tv(&var1);
@ -2274,11 +2275,16 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
if (op != NULL && *op != '=') { if (op != NULL && *op != '=') {
typval_T tv; typval_T tv;
/* handle +=, -= and .= */ // handle +=, -= and .=
di = NULL;
if (get_var_tv(lp->ll_name, (int)STRLEN(lp->ll_name), if (get_var_tv(lp->ll_name, (int)STRLEN(lp->ll_name),
&tv, TRUE, FALSE) == OK) { &tv, &di, true, false) == OK) {
if (tv_op(&tv, rettv, op) == OK) if ((di == NULL
set_var(lp->ll_name, &tv, FALSE); || (!var_check_ro(di->di_flags, lp->ll_name, false) &&
!tv_check_lock(di->di_tv.v_lock, lp->ll_name, false)))
&& tv_op(&tv, rettv, op) == OK) {
set_var(lp->ll_name, &tv, false);
}
clear_tv(&tv); clear_tv(&tv);
} }
} else } else
@ -2287,15 +2293,16 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
} }
} 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_name)) : lp->ll_tv->vval.v_dict->dv_lock,
; lp->ll_name, false)) {
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;
// Check whether any of the list items is locked // Check whether any of the list items is locked
for (listitem_T *ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; ) { for (listitem_T *ri = rettv->vval.v_list->lv_first;
if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name)) { ri != NULL && ll_li != NULL; ) {
if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, false)) {
return; return;
} }
ri = ri->li_next; ri = ri->li_next;
@ -2891,9 +2898,9 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
ret = FAIL; ret = FAIL;
*name_end = cc; *name_end = cc;
} else if ((lp->ll_list != NULL } else if ((lp->ll_list != NULL
&& tv_check_lock(lp->ll_list->lv_lock, lp->ll_name)) && tv_check_lock(lp->ll_list->lv_lock, lp->ll_name, false))
|| (lp->ll_dict != NULL || (lp->ll_dict != NULL
&& tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name))) { && tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name, false))) {
return FAIL; return FAIL;
} else if (lp->ll_range) { } else if (lp->ll_range) {
listitem_T *li; listitem_T *li;
@ -2902,7 +2909,7 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
while (ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= ll_n1)) { while (ll_li != NULL && (lp->ll_empty2 || lp->ll_n2 >= ll_n1)) {
li = ll_li->li_next; li = ll_li->li_next;
if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name)) { if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, false)) {
return false; return false;
} }
ll_li = li; ll_li = li;
@ -2975,9 +2982,9 @@ int do_unlet(char_u *name, int forceit)
hi = hash_find(ht, varname); hi = hash_find(ht, varname);
if (!HASHITEM_EMPTY(hi)) { if (!HASHITEM_EMPTY(hi)) {
di = HI2DI(hi); di = HI2DI(hi);
if (var_check_fixed(di->di_flags, name) if (var_check_fixed(di->di_flags, name, false)
|| var_check_ro(di->di_flags, name) || var_check_ro(di->di_flags, name, false)
|| tv_check_lock(d->dv_lock, name)) { || tv_check_lock(d->dv_lock, name, false)) {
return FAIL; return FAIL;
} }
typval_T oldtv; typval_T oldtv;
@ -4240,7 +4247,7 @@ static int eval7(
ret = FAIL; ret = FAIL;
} }
} else if (evaluate) { } else if (evaluate) {
ret = get_var_tv(s, len, rettv, true, false); ret = get_var_tv(s, len, rettv, NULL, true, false);
} else { } else {
ret = OK; ret = OK;
} }
@ -7856,7 +7863,8 @@ static void f_add(typval_T *argvars, typval_T *rettv)
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) {
if ((l = argvars[0].vval.v_list) != NULL if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, (char_u *)_("add() argument"))) { && !tv_check_lock(l->lv_lock,
(char_u *)N_("add() argument"), true)) {
list_append_tv(l, &argvars[1]); list_append_tv(l, &argvars[1]);
copy_tv(&argvars[0], rettv); copy_tv(&argvars[0], rettv);
} }
@ -9131,9 +9139,10 @@ static void f_exists(typval_T *argvars, typval_T *rettv)
name = p; name = p;
len = get_name_len(&p, &tofree, TRUE, FALSE); len = get_name_len(&p, &tofree, TRUE, FALSE);
if (len > 0) { if (len > 0) {
if (tofree != NULL) if (tofree != NULL) {
name = tofree; name = tofree;
n = (get_var_tv(name, len, &tv, FALSE, TRUE) == OK); }
n = (get_var_tv(name, len, &tv, NULL, false, true) == OK);
if (n) { if (n) {
/* handle d.key, l[idx], f(expr) */ /* handle d.key, l[idx], f(expr) */
n = (handle_subscript(&p, &tv, TRUE, FALSE) == OK); n = (handle_subscript(&p, &tv, TRUE, FALSE) == OK);
@ -9231,7 +9240,7 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
hashitem_T *hi2; hashitem_T *hi2;
int todo; int todo;
bool watched = is_watched(d1); bool watched = is_watched(d1);
char *arg_errmsg = N_("extend() argument"); char_u *arg_errmsg = (char_u *)N_("extend() argument");
todo = (int)d2->dv_hashtab.ht_used; todo = (int)d2->dv_hashtab.ht_used;
for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) { for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) {
@ -9265,8 +9274,8 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
} else if (*action == 'f' && HI2DI(hi2) != di1) { } else if (*action == 'f' && HI2DI(hi2) != di1) {
typval_T oldtv; typval_T oldtv;
if (tv_check_lock(di1->di_tv.v_lock, (char_u *)_(arg_errmsg)) if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, true)
|| var_check_ro(di1->di_flags, (char_u *)_(arg_errmsg))) { || var_check_ro(di1->di_flags, arg_errmsg, true)) {
break; break;
} }
@ -9292,7 +9301,7 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
*/ */
static void f_extend(typval_T *argvars, typval_T *rettv) static void f_extend(typval_T *argvars, typval_T *rettv)
{ {
char *arg_errmsg = N_("extend() argument"); char_u *arg_errmsg = (char_u *)N_("extend() argument");
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) {
list_T *l1, *l2; list_T *l1, *l2;
@ -9302,7 +9311,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv)
l1 = argvars[0].vval.v_list; l1 = argvars[0].vval.v_list;
l2 = argvars[1].vval.v_list; l2 = argvars[1].vval.v_list;
if (l1 != NULL && !tv_check_lock(l1->lv_lock, (char_u *)_(arg_errmsg)) if (l1 != NULL && !tv_check_lock(l1->lv_lock, arg_errmsg, true)
&& l2 != NULL) { && l2 != NULL) {
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
before = get_tv_number_chk(&argvars[2], &error); before = get_tv_number_chk(&argvars[2], &error);
@ -9332,7 +9341,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv)
d1 = argvars[0].vval.v_dict; d1 = argvars[0].vval.v_dict;
d2 = argvars[1].vval.v_dict; d2 = argvars[1].vval.v_dict;
if (d1 != NULL && !tv_check_lock(d1->dv_lock, (char_u *)_(arg_errmsg)) if (d1 != NULL && !tv_check_lock(d1->dv_lock, arg_errmsg, true)
&& d2 != NULL) { && d2 != NULL) {
/* Check the third argument. */ /* Check the third argument. */
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
@ -9478,19 +9487,19 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
int rem; int rem;
int todo; int todo;
char_u *ermsg = (char_u *)(map ? "map()" : "filter()"); char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
char *arg_errmsg = (map ? N_("map() argument") char_u *arg_errmsg = (char_u *)(map ? N_("map() argument")
: N_("filter() argument")); : N_("filter() argument"));
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, (char_u *)_(arg_errmsg)))) { || (!map && tv_check_lock(l->lv_lock, arg_errmsg, true))) {
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, (char_u *)_(arg_errmsg)))) { || (!map && tv_check_lock(d->dv_lock, arg_errmsg, true))) {
return; return;
} }
} else { } else {
@ -9524,8 +9533,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
di = HI2DI(hi); di = HI2DI(hi);
if (map if (map
&& (tv_check_lock(di->di_tv.v_lock, (char_u *)_(arg_errmsg)) && (tv_check_lock(di->di_tv.v_lock, arg_errmsg, true)
|| var_check_ro(di->di_flags, (char_u *)_(arg_errmsg)))) { || var_check_ro(di->di_flags, arg_errmsg, true))) {
break; break;
} }
@ -9535,8 +9544,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
if (r == FAIL || did_emsg) if (r == FAIL || did_emsg)
break; break;
if (!map && rem) { if (!map && rem) {
if (var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg)) if (var_check_fixed(di->di_flags, arg_errmsg, true)
|| var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) { || var_check_ro(di->di_flags, arg_errmsg, true)) {
break; break;
} }
dictitem_remove(d, di); dictitem_remove(d, di);
@ -9548,7 +9557,7 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
vimvars[VV_KEY].vv_type = VAR_NUMBER; vimvars[VV_KEY].vv_type = VAR_NUMBER;
for (li = l->lv_first; li != NULL; li = nli) { for (li = l->lv_first; li != NULL; li = nli) {
if (map && tv_check_lock(li->li_tv.v_lock, (char_u *)_(arg_errmsg))) { if (map && tv_check_lock(li->li_tv.v_lock, arg_errmsg, true)) {
break; break;
} }
nli = li->li_next; nli = li->li_next;
@ -11443,14 +11452,18 @@ static void f_insert(typval_T *argvars, typval_T *rettv)
list_T *l; list_T *l;
int error = FALSE; int error = FALSE;
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, (char_u *)_("insert() argument"))) { && !tv_check_lock(l->lv_lock,
if (argvars[2].v_type != VAR_UNKNOWN) (char_u *)N_("insert() argument"), true)) {
if (argvars[2].v_type != VAR_UNKNOWN) {
before = get_tv_number_chk(&argvars[2], &error); before = get_tv_number_chk(&argvars[2], &error);
if (error) }
return; /* type error; errmsg already given */ if (error) {
// type error; errmsg already given
return;
}
if (before == l->lv_len) if (before == l->lv_len)
item = NULL; item = NULL;
@ -13904,20 +13917,20 @@ static void f_remove(typval_T *argvars, typval_T *rettv)
char_u *key; char_u *key;
dict_T *d; dict_T *d;
dictitem_T *di; dictitem_T *di;
char *arg_errmsg = N_("remove() argument"); char_u *arg_errmsg = (char_u *)N_("remove() argument");
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, (char_u *)_(arg_errmsg))) { && !tv_check_lock(d->dv_lock, arg_errmsg, true)) {
key = get_tv_string_chk(&argvars[1]); key = get_tv_string_chk(&argvars[1]);
if (key != NULL) { if (key != NULL) {
di = dict_find(d, key, -1); di = 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, (char_u *)_(arg_errmsg)) } else if (!var_check_fixed(di->di_flags, arg_errmsg, true)
&& !var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) { && !var_check_ro(di->di_flags, arg_errmsg, true)) {
*rettv = di->di_tv; *rettv = di->di_tv;
init_tv(&di->di_tv); init_tv(&di->di_tv);
dictitem_remove(d, di); dictitem_remove(d, di);
@ -13927,11 +13940,11 @@ static void f_remove(typval_T *argvars, typval_T *rettv)
} }
} }
} }
} 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, (char_u *)_(arg_errmsg))) { && !tv_check_lock(l->lv_lock, arg_errmsg, true)) {
int error = FALSE; int error = (int)false;
idx = get_tv_number_chk(&argvars[1], &error); idx = get_tv_number_chk(&argvars[1], &error);
if (error) if (error)
@ -14205,10 +14218,11 @@ static void f_reverse(typval_T *argvars, typval_T *rettv)
list_T *l; list_T *l;
listitem_T *li, *ni; listitem_T *li, *ni;
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, (char_u *)_("reverse() argument"))) { && !tv_check_lock(l->lv_lock,
(char_u *)N_("reverse() argument"), true)) {
li = l->lv_last; 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;
@ -15742,8 +15756,12 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
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 || tv_check_lock(l->lv_lock, if (l == NULL ||
(char_u *)(sort ? _("sort() argument") : _("uniq() argument")))) { tv_check_lock(l->lv_lock,
(char_u *)(sort
? N_("sort() argument")
: N_("uniq() argument")),
true)) {
return; return;
} }
rettv->vval.v_list = l; rettv->vval.v_list = l;
@ -18166,10 +18184,11 @@ char_u *set_cmdarg(exarg_T *eap, char_u *oldarg)
static int static int
get_var_tv ( get_var_tv (
char_u *name, char_u *name,
int len, /* length of "name" */ int len, // length of "name"
typval_T *rettv, /* NULL when only checking existence */ typval_T *rettv, // NULL when only checking existence
int verbose, /* may give error message */ dictitem_T **dip, // non-NULL when typval's dict item is needed
int no_autoload /* do not use script autoloading */ int verbose, // may give error message
int no_autoload // do not use script autoloading
) )
{ {
int ret = OK; int ret = OK;
@ -18195,8 +18214,12 @@ get_var_tv (
*/ */
else { else {
v = find_var(name, NULL, no_autoload); v = find_var(name, NULL, no_autoload);
if (v != NULL) if (v != NULL) {
tv = &v->di_tv; tv = &v->di_tv;
if (dip != NULL) {
*dip = v;
}
}
} }
if (tv == NULL) { if (tv == NULL) {
@ -18863,10 +18886,11 @@ set_var (
return; return;
if (v != NULL) { if (v != NULL) {
/* existing variable, need to clear the value */ // existing variable, need to clear the value
if (var_check_ro(v->di_flags, name) if (var_check_ro(v->di_flags, name, false)
|| tv_check_lock(v->di_tv.v_lock, name)) || tv_check_lock(v->di_tv.v_lock, name, false)) {
return; return;
}
if (v->di_tv.v_type != tv->v_type if (v->di_tv.v_type != tv->v_type
&& !((v->di_tv.v_type == VAR_STRING && !((v->di_tv.v_type == VAR_STRING
|| v->di_tv.v_type == VAR_NUMBER) || v->di_tv.v_type == VAR_NUMBER)
@ -18881,10 +18905,8 @@ set_var (
return; return;
} }
/* // Handle setting internal v: variables separately where needed to
* Handle setting internal v: variables separately: we don't change // prevent changing the type.
* the type.
*/
if (ht == &vimvarht) { if (ht == &vimvarht) {
if (v->di_tv.v_type == VAR_STRING) { if (v->di_tv.v_type == VAR_STRING) {
xfree(v->di_tv.vval.v_string); xfree(v->di_tv.vval.v_string);
@ -18895,9 +18917,8 @@ set_var (
v->di_tv.vval.v_string = tv->vval.v_string; v->di_tv.vval.v_string = tv->vval.v_string;
tv->vval.v_string = NULL; tv->vval.v_string = NULL;
} }
} else if (v->di_tv.v_type != VAR_NUMBER) return;
EMSG2(_(e_intern2), "set_var()"); } else if (v->di_tv.v_type == VAR_NUMBER) {
else {
v->di_tv.vval.v_number = get_tv_number(tv); v->di_tv.vval.v_number = get_tv_number(tv);
if (STRCMP(varname, "searchforward") == 0) if (STRCMP(varname, "searchforward") == 0)
set_search_direction(v->di_tv.vval.v_number ? '/' : '?'); set_search_direction(v->di_tv.vval.v_number ? '/' : '?');
@ -18905,8 +18926,10 @@ set_var (
no_hlsearch = !v->di_tv.vval.v_number; no_hlsearch = !v->di_tv.vval.v_number;
redraw_all_later(SOME_VALID); redraw_all_later(SOME_VALID);
} }
}
return; return;
} else if (v->di_tv.v_type != tv->v_type) {
EMSG2(_(e_intern2), "set_var()");
}
} }
if (watched) { if (watched) {
@ -18951,34 +18974,31 @@ set_var (
} }
} }
/* // Return true if di_flags "flags" indicates variable "name" is read-only.
* Return TRUE if di_flags "flags" indicates variable "name" is read-only. // Also give an error message.
* Also give an error message. static bool var_check_ro(int flags, char_u *name, bool use_gettext)
*/
static int var_check_ro(int flags, char_u *name)
{ {
if (flags & DI_FLAGS_RO) { if (flags & DI_FLAGS_RO) {
EMSG2(_(e_readonlyvar), name); EMSG2(_(e_readonlyvar), use_gettext ? (char_u *)_(name) : name);
return TRUE; return true;
} }
if ((flags & DI_FLAGS_RO_SBX) && sandbox) { if ((flags & DI_FLAGS_RO_SBX) && sandbox) {
EMSG2(_(e_readonlysbx), name); EMSG2(_(e_readonlysbx), use_gettext ? (char_u *)_(name) : name);
return TRUE; return true;
} }
return FALSE; return false;
} }
/* // Return true if di_flags "flags" indicates variable "name" is fixed.
* Return TRUE if di_flags "flags" indicates variable "name" is fixed. // Also give an error message.
* Also give an error message. static bool var_check_fixed(int flags, char_u *name, bool use_gettext)
*/
static int var_check_fixed(int flags, char_u *name)
{ {
if (flags & DI_FLAGS_FIX) { if (flags & DI_FLAGS_FIX) {
EMSG2(_("E795: Cannot delete variable %s"), name); EMSG2(_("E795: Cannot delete variable %s"),
return TRUE; use_gettext ? (char_u *)_(name) : name);
return true;
} }
return FALSE; return false;
} }
/* /*
@ -19026,23 +19046,28 @@ static int valid_varname(char_u *varname)
return TRUE; return TRUE;
} }
/* // Return true if typeval "tv" is set to be locked (immutable).
* Return TRUE if typeval "tv" is set to be locked (immutable). // Also give an error message, using "name" or _("name") when use_gettext is
* Also give an error message, using "name". // true.
*/ static bool tv_check_lock(int lock, char_u *name, bool use_gettext)
static int tv_check_lock(int lock, char_u *name)
{ {
if (lock & VAR_LOCKED) { if (lock & VAR_LOCKED) {
EMSG2(_("E741: Value is locked: %s"), EMSG2(_("E741: Value is locked: %s"),
name == NULL ? (char_u *)_("Unknown") : name); name == NULL
return TRUE; ? (char_u *)_("Unknown")
: use_gettext ? (char_u *)_(name)
: name);
return true;
} }
if (lock & VAR_FIXED) { if (lock & VAR_FIXED) {
EMSG2(_("E742: Cannot change value of %s"), EMSG2(_("E742: Cannot change value of %s"),
name == NULL ? (char_u *)_("Unknown") : name); name == NULL
return TRUE; ? (char_u *)_("Unknown")
: use_gettext ? (char_u *)_(name)
: name);
return true;
} }
return FALSE; return false;
} }
/* /*
@ -19862,13 +19887,14 @@ void ex_function(exarg_T *eap)
goto erret; goto erret;
} }
if (fudi.fd_di == NULL) { if (fudi.fd_di == NULL) {
/* Can't add a function to a locked dictionary */ if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg, false)) {
if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg)) // Can't add a function to a locked dictionary
goto erret; goto erret;
} }
/* Can't change an existing function if it is locked */ } else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg, false)) {
else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg)) // Can't change an existing function if it is locked
goto erret; goto erret;
}
/* Give the function a sequential number. Can only be used with a /* Give the function a sequential number. Can only be used with a
* Funcref! */ * Funcref! */

11
src/nvim/testdir/test55.in
View File

@ -442,6 +442,17 @@ let l = [0, 1, 2, 3]
:unlockvar 1 b: :unlockvar 1 b:
:unlet! b:testvar :unlet! b:testvar
:" :"
:$put ='No :let += of locked list variable:'
:let l = ['a', 'b', 3]
:lockvar 1 l
:try
: let l += ['x']
: $put ='did :let +='
:catch
: $put =v:exception[:14]
:endtry
:$put =string(l)
:"
:unlet l :unlet l
:let l = [1, 2, 3, 4] :let l = [1, 2, 3, 4]
:lockvar! l :lockvar! l

3
src/nvim/testdir/test55.ok
View File

@ -144,6 +144,9 @@ No extend() of write-protected scope-level variable:
Vim(put):E742: Vim(put):E742:
No :unlet of variable in locked scope: No :unlet of variable in locked scope:
Vim(unlet):E741: Vim(unlet):E741:
No :let += of locked list variable:
Vim(let):E741:
['a', 'b', 3]
[1, 2, 3, 4] [1, 2, 3, 4]
[1, 2, 3, 4] [1, 2, 3, 4]
[1, 2, 3, 4] [1, 2, 3, 4]

4
src/nvim/version.c
View File

@ -571,7 +571,7 @@ static int included_patches[] = {
// 720 NA // 720 NA
719, 719,
718, 718,
// 717, 717,
716, 716,
715, 715,
714, 714,
@ -580,7 +580,7 @@ static int included_patches[] = {
711, 711,
710, 710,
709, 709,
// 708, 708,
707, 707,
706, 706,
// 705 NA // 705 NA