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

vim-patch:8.2.1698: cannot lock a variable in legacy Vim script like in Vim9 (#21883)

Browse Source 
Problem:    Cannot lock a variable in legacy Vim script like in Vim9.
Solution:   Make ":lockvar 0" work.

a187c43cfe

Co-authored-by: Bram Moolenaar <Bram@vim.org>
This commit is contained in:
zeertzjq
2023-01-19 08:03:13 +08:00
committed by GitHub
parent 42d5142367
commit f8669e8a18
10 changed files with 115 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
runtime/doc/eval.txt
View File

@@ -2681,6 +2681,8 @@ text...
[depth] is relevant when locking a |List| or
|Dictionary|. It specifies how deep the locking goes:
0 Lock the variable {name} but not its
value.
1 Lock the |List| or |Dictionary| itself,
cannot add or remove items, but can
still change their values.
@@ -2694,7 +2696,14 @@ text...
|Dictionary|, one level deeper.
The default [depth] is 2, thus when {name} is a |List|
or |Dictionary| the values cannot be changed.
*E743*
Example with [depth] 0: >
let mylist = [1, 2, 3]
lockvar 0 mylist
let mylist[0] = 77 " OK
call add(mylist, 4] " OK
let mylist = [7, 8, 9] " Error!
< *E743*
For unlimited depth use [!] and omit [depth].
However, there is a maximum depth of 100 to catch
loops.

30
src/nvim/eval.c
View File

@@ -1485,9 +1485,9 @@ char *get_lval(char *const name, typval_T *const rettv, lval_T *const lp, const
tv_clear(&var1);
break;
// existing variable, need to check if it can be changed
} else if (!(flags & GLV_READ_ONLY) && var_check_ro(lp->ll_di->di_flags,
(const char *)name,
(size_t)(p - name))) {
} else if (!(flags & GLV_READ_ONLY)
&& (var_check_ro(lp->ll_di->di_flags, name, (size_t)(p - name))
|| var_check_lock(lp->ll_di->di_flags, name, (size_t)(p - name)))) {
tv_clear(&var1);
return NULL;
}
@@ -1618,7 +1618,7 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
semsg(_(e_letwrong), op);
return;
}
if (var_check_lock(lp->ll_blob->bv_lock, lp->ll_name, TV_CSTRING)) {
if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, TV_CSTRING)) {
return;
}
@@ -1681,10 +1681,10 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
set_var_const(lp->ll_name, lp->ll_name_len, rettv, copy, is_const);
}
*endp = (char)cc;
} else if (var_check_lock(lp->ll_newkey == NULL
? lp->ll_tv->v_lock
: lp->ll_tv->vval.v_dict->dv_lock,
lp->ll_name, TV_CSTRING)) {
} else if (value_check_lock(lp->ll_newkey == NULL
? lp->ll_tv->v_lock
: lp->ll_tv->vval.v_dict->dv_lock,
lp->ll_name, TV_CSTRING)) {
// Skip
} else if (lp->ll_range) {
listitem_T *ll_li = lp->ll_li;
@@ -1698,8 +1698,8 @@ void set_var_lval(lval_T *lp, char *endp, typval_T *rettv, int copy, const bool
// Check whether any of the list items is locked
for (ri = tv_list_first(rettv->vval.v_list);
ri != NULL && ll_li != NULL;) {
if (var_check_lock(TV_LIST_ITEM_TV(ll_li)->v_lock, lp->ll_name,
TV_CSTRING)) {
if (value_check_lock(TV_LIST_ITEM_TV(ll_li)->v_lock, lp->ll_name,
TV_CSTRING)) {
return;
}
ri = TV_LIST_ITEM_NEXT(rettv->vval.v_list, ri);
@@ -4795,12 +4795,12 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
} else if (argvars[0].v_type == VAR_LIST) {
if ((l = argvars[0].vval.v_list) == NULL
|| (!map
&& var_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE))) {
&& value_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE))) {
return;
}
} else if (argvars[0].v_type == VAR_DICT) {
if ((d = argvars[0].vval.v_dict) == NULL
|| (!map && var_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
|| (!map && value_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
return;
}
} else {
@@ -4839,7 +4839,7 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
dictitem_T *di = TV_DICT_HI2DI(hi);
if (map
&& (var_check_lock(di->di_tv.v_lock, arg_errmsg, TV_TRANSLATE)
&& (value_check_lock(di->di_tv.v_lock, arg_errmsg, TV_TRANSLATE)
|| var_check_ro(di->di_flags, arg_errmsg, TV_TRANSLATE))) {
break;
}
@@ -4899,8 +4899,8 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
}
for (listitem_T *li = tv_list_first(l); li != NULL;) {
if (map
&& var_check_lock(TV_LIST_ITEM_TV(li)->v_lock, arg_errmsg,
TV_TRANSLATE)) {
&& value_check_lock(TV_LIST_ITEM_TV(li)->v_lock, arg_errmsg,
TV_TRANSLATE)) {
break;
}
vimvars[VV_KEY].vv_nr = idx;

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

@@ -362,15 +362,15 @@ static void f_add(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
rettv->vval.v_number = 1; // Default: failed.
if (argvars[0].v_type == VAR_LIST) {
list_T *const l = argvars[0].vval.v_list;
if (!var_check_lock(tv_list_locked(l), N_("add() argument"),
TV_TRANSLATE)) {
if (!value_check_lock(tv_list_locked(l), N_("add() argument"),
TV_TRANSLATE)) {
tv_list_append_tv(l, &argvars[1]);
tv_copy(&argvars[0], rettv);
}
} else if (argvars[0].v_type == VAR_BLOB) {
blob_T *const b = argvars[0].vval.v_blob;
if (b != NULL
&& !var_check_lock(b->bv_lock, N_("add() argument"), TV_TRANSLATE)) {
&& !value_check_lock(b->bv_lock, N_("add() argument"), TV_TRANSLATE)) {
bool error = false;
const varnumber_T n = tv_get_number_chk(&argvars[1], &error);
@@ -1896,9 +1896,9 @@ static void f_flatten(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
list_T *list = argvars[0].vval.v_list;
if (list != NULL
&& !var_check_lock(tv_list_locked(list),
N_("flatten() argument"),
TV_TRANSLATE)
&& !value_check_lock(tv_list_locked(list),
N_("flatten() argument"),
TV_TRANSLATE)
&& tv_list_flatten(list, maxdepth) == OK) {
tv_copy(&argvars[0], rettv);
}
@@ -1915,7 +1915,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
list_T *const l1 = argvars[0].vval.v_list;
list_T *const l2 = argvars[1].vval.v_list;
if (!var_check_lock(tv_list_locked(l1), arg_errmsg, TV_TRANSLATE)) {
if (!value_check_lock(tv_list_locked(l1), arg_errmsg, TV_TRANSLATE)) {
listitem_T *item;
if (argvars[2].v_type != VAR_UNKNOWN) {
long before = (long)tv_get_number_chk(&argvars[2], &error);
@@ -1944,13 +1944,13 @@ static void f_extend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
dict_T *const d1 = argvars[0].vval.v_dict;
dict_T *const d2 = argvars[1].vval.v_dict;
if (d1 == NULL) {
const bool locked = var_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
const bool locked = value_check_lock(VAR_FIXED, arg_errmsg, TV_TRANSLATE);
(void)locked;
assert(locked == true);
} else if (d2 == NULL) {
// Do nothing
tv_copy(&argvars[0], rettv);
} else if (!var_check_lock(d1->dv_lock, arg_errmsg, TV_TRANSLATE)) {
} else if (!value_check_lock(d1->dv_lock, arg_errmsg, TV_TRANSLATE)) {
const char *action = "force";
// Check the third argument.
if (argvars[2].v_type != VAR_UNKNOWN) {
@@ -3556,8 +3556,8 @@ static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
blob_T *const b = argvars[0].vval.v_blob;
if (b == NULL
|| var_check_lock(b->bv_lock, N_("insert() argument"),
TV_TRANSLATE)) {
|| value_check_lock(b->bv_lock, N_("insert() argument"),
TV_TRANSLATE)) {
return;
}
@@ -3592,8 +3592,8 @@ static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
tv_copy(&argvars[0], rettv);
} else if (argvars[0].v_type != VAR_LIST) {
semsg(_(e_listblobarg), "insert()");
} else if (!var_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
N_("insert() argument"), TV_TRANSLATE)) {
} else if (!value_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
N_("insert() argument"), TV_TRANSLATE)) {
long before = 0;
if (argvars[2].v_type != VAR_UNKNOWN) {
before = tv_get_number_chk(&argvars[2], &error);
@@ -5985,8 +5985,8 @@ static void f_reverse(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
semsg(_(e_listblobarg), "reverse()");
} else {
list_T *const l = argvars[0].vval.v_list;
if (!var_check_lock(tv_list_locked(l), N_("reverse() argument"),
TV_TRANSLATE)) {
if (!value_check_lock(tv_list_locked(l), N_("reverse() argument"),
TV_TRANSLATE)) {
tv_list_reverse(l);
tv_list_set_ret(rettv, l);
}

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

@@ -900,8 +900,8 @@ void tv_list_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
list_T *l;
bool error = false;
if (var_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
arg_errmsg, TV_TRANSLATE)) {
if (value_check_lock(tv_list_locked((l = argvars[0].vval.v_list)),
arg_errmsg, TV_TRANSLATE)) {
return;
}
@@ -1156,7 +1156,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
semsg(_(e_listarg), sort ? "sort()" : "uniq()");
} else {
list_T *const l = argvars[0].vval.v_list;
if (var_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE)) {
if (value_check_lock(tv_list_locked(l), arg_errmsg, TV_TRANSLATE)) {
goto theend;
}
tv_list_set_ret(rettv, l);
@@ -2494,7 +2494,7 @@ void tv_dict_extend(dict_T *const d1, dict_T *const d2, const char *const action
} else if (*action == 'f' && di2 != di1) {
typval_T oldtv;
if (var_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
if (value_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
|| var_check_ro(di1->di_flags, arg_errmsg, arg_errmsg_len)) {
break;
}
@@ -2710,7 +2710,7 @@ void tv_blob_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
{
blob_T *const b = argvars[0].vval.v_blob;
if (b != NULL && var_check_lock(b->bv_lock, arg_errmsg, TV_TRANSLATE)) {
if (b != NULL && value_check_lock(b->bv_lock, arg_errmsg, TV_TRANSLATE)) {
return;
}
@@ -2902,7 +2902,7 @@ void tv_dict_remove(typval_T *argvars, typval_T *rettv, const char *arg_errmsg)
if (argvars[2].v_type != VAR_UNKNOWN) {
semsg(_(e_toomanyarg), "remove()");
} else if ((d = argvars[0].vval.v_dict) != NULL
&& !var_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE)) {
&& !value_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE)) {
const char *key = tv_get_string_chk(&argvars[1]);
if (key != NULL) {
dictitem_T *di = tv_dict_find(d, key, -1);
@@ -3460,12 +3460,12 @@ bool tv_check_lock(const typval_T *tv, const char *name, size_t name_len)
default:
break;
}
return var_check_lock(tv->v_lock, name, name_len)
|| (lock != VAR_UNLOCKED && var_check_lock(lock, name, name_len));
return value_check_lock(tv->v_lock, name, name_len)
|| (lock != VAR_UNLOCKED && value_check_lock(lock, name, name_len));
}
/// @return true if variable "name" is locked (immutable)
bool var_check_lock(VarLockStatus lock, const char *name, size_t name_len)
/// @return true if variable "name" has a locked (immutable) value
bool value_check_lock(VarLockStatus lock, const char *name, size_t name_len)
{
const char *error_message = NULL;
switch (lock) {

8
src/nvim/eval/userfunc.c
View File

@@ -2551,13 +2551,13 @@ void ex_function(exarg_T *eap)
goto erret;
}
if (fudi.fd_di == NULL) {
if (var_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
TV_CSTRING)) {
if (value_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
TV_CSTRING)) {
// Can't add a function to a locked dictionary
goto erret;
}
} else if (var_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg,
TV_CSTRING)) {
} else if (value_check_lock(fudi.fd_di->di_tv.v_lock, (const char *)eap->arg,
TV_CSTRING)) {
// Can't change an existing function if it is locked
goto erret;
}

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

@@ -877,13 +877,13 @@ static int do_unlet_var(lval_T *lp, char *name_end, exarg_T *eap, int deep FUNC_
} else if ((lp->ll_list != NULL
// ll_list is not NULL when lvalue is not in a list, NULL lists
// yield E689.
&& var_check_lock(tv_list_locked(lp->ll_list),
lp->ll_name,
lp->ll_name_len))
&& value_check_lock(tv_list_locked(lp->ll_list),
lp->ll_name,
lp->ll_name_len))
|| (lp->ll_dict != NULL
&& var_check_lock(lp->ll_dict->dv_lock,
lp->ll_name,
lp->ll_name_len))) {
&& value_check_lock(lp->ll_dict->dv_lock,
lp->ll_name,
lp->ll_name_len))) {
return FAIL;
} else if (lp->ll_range) {
assert(lp->ll_list != NULL);
@@ -892,9 +892,9 @@ static int do_unlet_var(lval_T *lp, char *name_end, exarg_T *eap, int deep FUNC_
listitem_T *last_li = first_li;
for (;;) {
listitem_T *const li = TV_LIST_ITEM_NEXT(lp->ll_list, lp->ll_li);
if (var_check_lock(TV_LIST_ITEM_TV(lp->ll_li)->v_lock,
lp->ll_name,
lp->ll_name_len)) {
if (value_check_lock(TV_LIST_ITEM_TV(lp->ll_li)->v_lock,
lp->ll_name,
lp->ll_name_len)) {
return false;
}
lp->ll_li = li;
@@ -976,11 +976,11 @@ int do_unlet(const char *const name, const size_t name_len, const bool forceit)
dictitem_T *const di = TV_DICT_HI2DI(hi);
if (var_check_fixed(di->di_flags, name, TV_CSTRING)
|| var_check_ro(di->di_flags, name, TV_CSTRING)
|| var_check_lock(d->dv_lock, name, TV_CSTRING)) {
|| value_check_lock(d->dv_lock, name, TV_CSTRING)) {
return FAIL;
}
if (var_check_lock(d->dv_lock, name, TV_CSTRING)) {
if (value_check_lock(d->dv_lock, name, TV_CSTRING)) {
return FAIL;
}
@@ -1023,10 +1023,6 @@ static int do_lock_var(lval_T *lp, char *name_end FUNC_ATTR_UNUSED, exarg_T *eap
bool lock = eap->cmdidx == CMD_lockvar;
int ret = OK;
if (deep == 0) { // Nothing to do.
return OK;
}
if (lp->ll_tv == NULL) {
if (*lp->ll_name == '$') {
semsg(_(e_lock_unlock), lp->ll_name);
@@ -1050,9 +1046,13 @@ static int do_lock_var(lval_T *lp, char *name_end FUNC_ATTR_UNUSED, exarg_T *eap
} else {
di->di_flags &= (uint8_t)(~DI_FLAGS_LOCK);
}
tv_item_lock(&di->di_tv, deep, lock, false);
if (deep != 0) {
tv_item_lock(&di->di_tv, deep, lock, false);
}
}
}
} else if (deep == 0) {
// nothing to do
} else if (lp->ll_range) {
listitem_T *li = lp->ll_li;
@@ -1282,12 +1282,18 @@ void set_var_const(const char *name, const size_t name_len, typval_T *const tv,
return;
}
// existing variable, need to clear the value
// Check in this order for backwards compatibility:
// - Whether the variable is read-only
// - Whether the variable value is locked
// - Whether the variable is locked
if (var_check_ro(v->di_flags, name, name_len)
|| var_check_lock(v->di_tv.v_lock, name, name_len)) {
|| value_check_lock(v->di_tv.v_lock, name, name_len)
|| var_check_lock(v->di_flags, name, name_len)) {
return;
}
// existing variable, need to clear the value
// Handle setting internal v: variables separately where needed to
// prevent changing the type.
if (is_vimvarht(ht)) {
@@ -1418,6 +1424,26 @@ bool var_check_ro(const int flags, const char *name, size_t name_len)
return true;
}
/// Return true if di_flags "flags" indicates variable "name" is locked.
/// Also give an error message.
bool var_check_lock(const int flags, const char *name, size_t name_len)
{
if (!(flags & DI_FLAGS_LOCK)) {
return false;
}
if (name_len == TV_TRANSLATE) {
name = _(name);
name_len = strlen(name);
} else if (name_len == TV_CSTRING) {
name_len = strlen(name);
}
semsg(_("E1122: Variable is locked: %*s"), (int)name_len, name);
return true;
}
/// Check whether variable is fixed (DI_FLAGS_FIX)
///
/// Also gives an error message.

8
src/nvim/testdir/test_const.vim
View File

@@ -194,6 +194,14 @@ func Test_lockvar()
if 0 | lockvar x | endif
let x = 'again'
let val = [1, 2, 3]
lockvar 0 val
let val[0] = 9
call assert_equal([9, 2, 3], val)
call add(val, 4)
call assert_equal([9, 2, 3, 4], val)
call assert_fails('let val = [4, 5, 6]', 'E1122:')
endfunc

13
src/nvim/testdir/test_listdict.vim
View File

@@ -357,7 +357,7 @@ endfunc
" Locked variables
func Test_list_locked_var()
let expected = [
\ [['0000-000', 'ppppppp'],
\ [['1000-000', 'ppppppF'],
\ ['0000-000', 'ppppppp'],
\ ['0000-000', 'ppppppp']],
\ [['1000-000', 'ppppppF'],
@@ -384,7 +384,7 @@ func Test_list_locked_var()
exe "unlockvar " . depth . " l"
endif
let ps = islocked("l").islocked("l[1]").islocked("l[1][1]").islocked("l[1][1][0]").'-'.islocked("l[2]").islocked("l[2]['6']").islocked("l[2]['6'][7]")
call assert_equal(expected[depth][u][0], ps)
call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
let ps = ''
try
let l[1][1][0] = 99
@@ -428,7 +428,7 @@ func Test_list_locked_var()
catch
let ps .= 'F'
endtry
call assert_equal(expected[depth][u][1], ps)
call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth)
endfor
endfor
call assert_fails("let x=islocked('a b')", 'E488:')
@@ -441,7 +441,7 @@ endfunc
" Unletting locked variables
func Test_list_locked_var_unlet()
let expected = [
\ [['0000-000', 'ppppppp'],
\ [['1000-000', 'ppppppp'],
\ ['0000-000', 'ppppppp'],
\ ['0000-000', 'ppppppp']],
\ [['1000-000', 'ppFppFp'],
@@ -469,7 +469,7 @@ func Test_list_locked_var_unlet()
exe "unlockvar " . depth . " l"
endif
let ps = islocked("l").islocked("l[1]").islocked("l[1][1]").islocked("l[1][1][0]").'-'.islocked("l[2]").islocked("l[2]['6']").islocked("l[2]['6'][7]")
call assert_equal(expected[depth][u][0], ps)
call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
let ps = ''
try
unlet l[2]['6'][7]
@@ -673,6 +673,9 @@ func Test_func_arg_list()
call s:arg_list_test(1, 2, [3, 4], {5: 6})
endfunc
func Test_dict_item_locked()
endfunc
" Tests for reverse(), sort(), uniq()
func Test_reverse_sort_uniq()
let l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5]

232
test/functional/legacy/055_list_and_dict_types_spec.lua
View File

@@ -330,214 +330,6 @@ describe('list and dictionary types', function()
same list: 1]])
end)
it('locked variables (part 1)', function()
source([=[
let l = []
for depth in range(5)
$put ='depth is ' . depth
for u in range(3)
unlet l
let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}]
exe "lockvar " . depth . " l"
if u == 1
exe "unlockvar l"
elseif u == 2
exe "unlockvar " . depth . " l"
endif
let ps = islocked("l") . islocked("l[1]") . islocked("l[1][1]") .
\ islocked("l[1][1][0]") . '-' . islocked("l[2]") .
\ islocked("l[2]['6']") . islocked("l[2]['6'][7]")
$put =ps
let ps = ''
try
let l[1][1][0] = 99
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l[1][1] = [99]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l[1] = [99]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l[2]['6'][7] = 99
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l[2][6] = {99: 99}
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l[2] = {99: 99}
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
let l = [99]
let ps .= 'p'
catch
let ps .= 'F'
endtry
$put =ps
endfor
endfor]=])
expect([[
depth is 0
0000-000
ppppppp
0000-000
ppppppp
0000-000
ppppppp
depth is 1
1000-000
ppppppF
0000-000
ppppppp
0000-000
ppppppp
depth is 2
1100-100
ppFppFF
0000-000
ppppppp
0000-000
ppppppp
depth is 3
1110-110
pFFpFFF
0010-010
pFppFpp
0000-000
ppppppp
depth is 4
1111-111
FFFFFFF
0011-011
FFpFFpp
0000-000
ppppppp]])
end)
-- TODO In the original test the 5th line of this source() call was used.
-- But now the test only passes if I comment it.
it('unletting locked variables', function()
source([=[
let l = []
for depth in range(5)
$put ='depth is ' . depth
for u in range(3)
"unlet l
let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}]
exe "lockvar " . depth . " l"
if u == 1
exe "unlockvar l"
elseif u == 2
exe "unlockvar " . depth . " l"
endif
let ps = islocked("l") . islocked("l[1]") . islocked("l[1][1]") .
\ islocked("l[1][1][0]") . '-' . islocked("l[2]") .
\ islocked("l[2]['6']") . islocked("l[2]['6'][7]")
$put =ps
let ps = ''
try
unlet l[2]['6'][7]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l[2][6]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l[2]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l[1][1][0]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l[1][1]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l[1]
let ps .= 'p'
catch
let ps .= 'F'
endtry
try
unlet l
let ps .= 'p'
catch
let ps .= 'F'
endtry
$put =ps
endfor
endfor]=])
expect([[
depth is 0
0000-000
ppppppp
0000-000
ppppppp
0000-000
ppppppp
depth is 1
1000-000
ppFppFp
0000-000
ppppppp
0000-000
ppppppp
depth is 2
1100-100
pFFpFFp
0000-000
ppppppp
0000-000
ppppppp
depth is 3
1110-110
FFFFFFp
0010-010
FppFppp
0000-000
ppppppp
depth is 4
1111-111
FFFFFFp
0011-011
FppFppp
0000-000
ppppppp]])
end)
it('locked variables and :unlet or list / dict functions', function()
source([[
$put ='Locks and commands or functions:'
@@ -676,30 +468,6 @@ describe('list and dictionary types', function()
['a', 'b', 3]]=])
end)
it('locked variables (part 2)', function()
feed_command(
'let l = [1, 2, 3, 4]',
'lockvar! l',
'$put =string(l)',
'unlockvar l[1]',
'unlet l[0:1]',
'$put =string(l)',
'unlet l[1:2]',
'$put =string(l)',
'unlockvar l[1]',
'let l[0:1] = [0, 1]',
'$put =string(l)',
'let l[1:2] = [0, 1]',
'$put =string(l)')
expect([=[
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]]=])
end)
it(':lockvar/islocked() triggering script autoloading.', function()
source([[
set rtp+=test/functional/fixtures

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

@@ -2625,7 +2625,7 @@ describe('typval.c', function()
describe('check_lock()', function()
local function tv_check_lock(lock, name, name_len, emsg)
return check_emsg(function()
return lib.var_check_lock(lock, name, name_len)
return lib.value_check_lock(lock, name, name_len)
end, emsg)
end
itp('works', function()