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

vim-patch:7.4.698

Browse Source 
Problem:    Various problems with locked and fixed lists and dictionaries.
Solution:   Disallow changing locked items, fix a crash, add tests. (Olaf
            Dabrunz)

9bc174b69d
This commit is contained in:
Jurica Bradaric
2016-01-27 21:35:58 +01:00
parent 130611fca3
commit ccab78046c
5 changed files with 284 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
src/nvim/eval.c
View File

@@ -2890,9 +2890,12 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
else if (do_unlet(lp->ll_name, forceit) == FAIL)
ret = FAIL;
*name_end = cc;
} else if (tv_check_lock(lp->ll_tv->v_lock, lp->ll_name))
} else if ((lp->ll_list != NULL
&& tv_check_lock(lp->ll_list->lv_lock, lp->ll_name))
|| (lp->ll_dict != NULL
&& tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name))) {
return FAIL;
else if (lp->ll_range) {
} else if (lp->ll_range) {
listitem_T *li;
listitem_T *ll_li = lp->ll_li;
int ll_n1 = lp->ll_n1;
@@ -2953,17 +2956,30 @@ int do_unlet(char_u *name, int forceit)
hashtab_T *ht;
hashitem_T *hi;
char_u *varname;
dict_T *d;
dictitem_T *di;
dict_T *dict;
ht = find_var_ht_dict(name, &varname, &dict);
if (ht != NULL && *varname != NUL) {
if (ht == &globvarht) {
d = &globvardict;
} else if (current_funccal != NULL
&& ht == &current_funccal->l_vars.dv_hashtab) {
d = &current_funccal->l_vars;
} else {
di = find_var_in_ht(ht, *name, (char_u *)"", false);
d = di->di_tv.vval.v_dict;
}
hi = hash_find(ht, varname);
if (!HASHITEM_EMPTY(hi)) {
di = HI2DI(hi);
if (var_check_fixed(di->di_flags, name)
|| var_check_ro(di->di_flags, name))
|| var_check_ro(di->di_flags, name)
|| tv_check_lock(d->dv_lock, name)) {
return FAIL;
}
typval_T oldtv;
bool watched = is_watched(dict);
@@ -6055,7 +6071,7 @@ dictitem_T *dictitem_alloc(char_u *key) FUNC_ATTR_NONNULL_RET
#ifndef __clang_analyzer__
STRCPY(di->di_key, key);
#endif
di->di_flags = 0;
di->di_flags = DI_FLAGS_ALLOC;
return di;
}
@@ -6067,7 +6083,7 @@ static dictitem_T *dictitem_copy(dictitem_T *org) FUNC_ATTR_NONNULL_RET
dictitem_T *di = xmalloc(sizeof(dictitem_T) + STRLEN(org->di_key));
STRCPY(di->di_key, org->di_key);
di->di_flags = 0;
di->di_flags = DI_FLAGS_ALLOC;
copy_tv(&org->di_tv, &di->di_tv);
return di;
@@ -6095,7 +6111,9 @@ static void dictitem_remove(dict_T *dict, dictitem_T *item)
void dictitem_free(dictitem_T *item)
{
clear_tv(&item->di_tv);
xfree(item);
if (item->di_flags & DI_FLAGS_ALLOC) {
xfree(item);
}
}
/// Make a copy of dictionary
@@ -9212,6 +9230,7 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
hashitem_T *hi2;
int todo;
bool watched = is_watched(d1);
char *arg_errmsg = N_("extend() argument");
todo = (int)d2->dv_hashtab.ht_used;
for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) {
@@ -9245,6 +9264,11 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
} else if (*action == 'f' && HI2DI(hi2) != di1) {
typval_T oldtv;
if (tv_check_lock(di1->di_tv.v_lock, (char_u *)_(arg_errmsg))
|| var_check_ro(di1->di_flags, (char_u *)_(arg_errmsg))) {
break;
}
if (watched) {
copy_tv(&di1->di_tv, &oldtv);
}
@@ -9460,12 +9484,14 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
if (argvars[0].v_type == VAR_LIST) {
if ((l = argvars[0].vval.v_list) == NULL
|| tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg)))
|| (!map && tv_check_lock(l->lv_lock, (char_u *)_(arg_errmsg)))) {
return;
}
} else if (argvars[0].v_type == VAR_DICT) {
if ((d = argvars[0].vval.v_dict) == NULL
|| tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg)))
|| (!map && tv_check_lock(d->dv_lock, (char_u *)_(arg_errmsg)))) {
return;
}
} else {
EMSG2(_(e_listdictarg), ermsg);
return;
@@ -9494,17 +9520,26 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
for (hi = ht->ht_array; todo > 0; ++hi) {
if (!HASHITEM_EMPTY(hi)) {
--todo;
di = HI2DI(hi);
if (tv_check_lock(di->di_tv.v_lock,
(char_u *)_(arg_errmsg)))
if (map
&& (tv_check_lock(di->di_tv.v_lock, (char_u *)_(arg_errmsg))
|| var_check_ro(di->di_flags, (char_u *)_(arg_errmsg)))) {
break;
}
vimvars[VV_KEY].vv_str = vim_strsave(di->di_key);
int r = filter_map_one(&di->di_tv, expr, map, &rem);
clear_tv(&vimvars[VV_KEY].vv_tv);
if (r == FAIL || did_emsg)
break;
if (!map && rem)
if (!map && rem) {
if (var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg))
|| var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) {
break;
}
dictitem_remove(d, di);
}
}
}
hash_unlock(ht);
@@ -9512,8 +9547,9 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
vimvars[VV_KEY].vv_type = VAR_NUMBER;
for (li = l->lv_first; li != NULL; li = nli) {
if (tv_check_lock(li->li_tv.v_lock, (char_u *)_(arg_errmsg)))
if (map && tv_check_lock(li->li_tv.v_lock, (char_u *)_(arg_errmsg))) {
break;
}
nli = li->li_next;
vimvars[VV_KEY].vv_nr = idx;
if (filter_map_one(&li->li_tv, expr, map, &rem) == FAIL
@@ -13878,9 +13914,10 @@ static void f_remove(typval_T *argvars, typval_T *rettv)
key = get_tv_string_chk(&argvars[1]);
if (key != NULL) {
di = dict_find(d, key, -1);
if (di == NULL)
if (di == NULL) {
EMSG2(_(e_dictkey), key);
else {
} else if (!var_check_fixed(di->di_flags, (char_u *)_(arg_errmsg))
&& !var_check_ro(di->di_flags, (char_u *)_(arg_errmsg))) {
*rettv = di->di_tv;
init_tv(&di->di_tv);
dictitem_remove(d, di);
@@ -18648,14 +18685,16 @@ static void vars_clear_ext(hashtab_T *ht, int free_val)
if (!HASHITEM_EMPTY(hi)) {
--todo;
/* Free the variable. Don't remove it from the hashtab,
* ht_array might change then. hash_clear() takes care of it
* later. */
// Free the variable. Don't remove it from the hashtab,
// ht_array might change then. hash_clear() takes care of it
// later.
v = HI2DI(hi);
if (free_val)
if (free_val) {
clear_tv(&v->di_tv);
if ((v->di_flags & DI_FLAGS_FIX) == 0)
}
if (v->di_flags & DI_FLAGS_ALLOC) {
xfree(v);
}
}
}
hash_clear(ht);
@@ -18829,7 +18868,7 @@ set_var (
xfree(v);
return;
}
v->di_flags = 0;
v->di_flags = DI_FLAGS_ALLOC;
}
if (copy || tv->v_type == VAR_NUMBER || tv->v_type == VAR_FLOAT) {
@@ -20720,7 +20759,7 @@ call_user_func (
v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
} else {
v = xmalloc(sizeof(dictitem_T) + STRLEN(name));
v->di_flags = DI_FLAGS_RO;
v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX | DI_FLAGS_ALLOC;
}
STRCPY(v->di_key, name);
hash_add(&fc->l_avars.dv_hashtab, DI2HIKEY(v));