OSDN > Pesquisar Software > Vim > SCM > hg > vim > Commit

Vim
Fork

vim: Commit

Mirror of the Vim source from https://github.com/vim/vim

Commit MetaInfo

Revisão	07e48ee8c3bb67239e9459fa9037918098bcc802 (tree)
Hora	2020-09-17 04:15:05
Autor	Bram Moolenaar <Bram@vim....>
Commiter	Bram Moolenaar

Mensagem de Log

patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9

Commit: https://github.com/vim/vim/commit/a187c43cfe8863d48b2159d695fedcb71f8525c1
Author: Bram Moolenaar <Bram@vim.org>
Date: Wed Sep 16 21:08:28 2020 +0200

patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9

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

Mudança Sumário

modified: runtime/doc/eval.txt (diff)
modified: src/dict.c (diff)
modified: src/eval.c (diff)
modified: src/evalvars.c (diff)
modified: src/list.c (diff)
modified: src/proto/evalvars.pro (diff)
modified: src/testdir/test_const.vim (diff)
modified: src/testdir/test_listdict.vim (diff)
modified: src/typval.c (diff)
modified: src/userfunc.c (diff)
modified: src/version.c (diff)

Diff

diff -r 3d2dc70119a7 -r 07e48ee8c3bb runtime/doc/eval.txt

--- a/runtime/doc/eval.txt Wed Sep 16 18:00:04 2020 +0200

+++ b/runtime/doc/eval.txt Wed Sep 16 21:15:05 2020 +0200

		@@ -12364,7 +12364,9 @@
12364	12364	< is equivalent to: >
12365	12365	:let x = 1
12366	12366	:lockvar! x
12367		-< This is useful if you want to make sure the variable
	12367	+< NOTE: in Vim9 script `:const` works differently, see
	12368	+ \|vim9-const\|
	12369	+ This is useful if you want to make sure the variable
12368	12370	is not modified. If the value is a List or Dictionary
12369	12371	literal then the items also cannot be changed: >
12370	12372	const ll = [1, 2, 3]

		@@ -12404,6 +12406,8 @@
12404	12406
12405	12407	[depth] is relevant when locking a \|List\| or
12406	12408	\|Dictionary\|. It specifies how deep the locking goes:
	12409	+ 0 Lock the variable {name} but not its
	12410	+ value.
12407	12411	1 Lock the \|List\| or \|Dictionary\| itself,
12408	12412	cannot add or remove items, but can
12409	12413	still change their values.

		@@ -12417,7 +12421,14 @@
12417	12421	\|Dictionary\|, one level deeper.
12418	12422	The default [depth] is 2, thus when {name} is a \|List\|
12419	12423	or \|Dictionary\| the values cannot be changed.
12420		- E743
	12424	+
	12425	+ Example with [depth] 0: >
	12426	+ let mylist = [1, 2, 3]
	12427	+ lockvar 0 mylist
	12428	+ let mylist[0] = 77 " OK
	12429	+ call add(mylist, 4] " OK
	12430	+ let mylist = [7, 8, 9] " Error!
	12431	+< E743
12421	12432	For unlimited depth use [!] and omit [depth].
12422	12433	However, there is a maximum depth of 100 to catch
12423	12434	loops.

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/dict.c

--- a/src/dict.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/dict.c Wed Sep 16 21:15:05 2020 +0200

		@@ -1009,7 +1009,7 @@
1009	1009	}
1010	1010	else if (*action == 'f' && HI2DI(hi2) != di1)
1011	1011	{
1012		- if (var_check_lock(di1->di_tv.v_lock, arg_errmsg, TRUE)
	1012	+ if (value_check_lock(di1->di_tv.v_lock, arg_errmsg, TRUE)
1013	1013	\|\| var_check_ro(di1->di_flags, arg_errmsg, TRUE))
1014	1014	break;
1015	1015	clear_tv(&di1->di_tv);

		@@ -1227,7 +1227,7 @@
1227	1227	if (argvars[2].v_type != VAR_UNKNOWN)
1228	1228	semsg(_(e_toomanyarg), "remove()");
1229	1229	else if ((d = argvars[0].vval.v_dict) != NULL
1230		- && !var_check_lock(d->dv_lock, arg_errmsg, TRUE))
	1230	+ && !value_check_lock(d->dv_lock, arg_errmsg, TRUE))
1231	1231	{
1232	1232	key = tv_get_string_chk(&argvars[1]);
1233	1233	if (key != NULL)

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/eval.c

--- a/src/eval.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/eval.c Wed Sep 16 21:15:05 2020 +0200

		@@ -1055,7 +1055,8 @@
1055	1055	}
1056	1056	// existing variable, need to check if it can be changed
1057	1057	else if ((flags & GLV_READ_ONLY) == 0
1058		- && var_check_ro(lp->ll_di->di_flags, name, FALSE))
	1058	+ && (var_check_ro(lp->ll_di->di_flags, name, FALSE)
	1059	+ \|\| var_check_lock(lp->ll_di->di_flags, name, FALSE)))
1059	1060	{
1060	1061	clear_tv(&var1);
1061	1062	return NULL;

		@@ -1220,7 +1221,7 @@
1220	1221	semsg(_(e_letwrong), op);
1221	1222	return;
1222	1223	}
1223		- if (var_check_lock(lp->ll_blob->bv_lock, lp->ll_name, FALSE))
	1224	+ if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, FALSE))
1224	1225	return;
1225	1226
1226	1227	if (lp->ll_range && rettv->v_type == VAR_BLOB)

		@@ -1297,7 +1298,7 @@
1297	1298	}
1298	1299	*endp = cc;
1299	1300	}
1300		- else if (var_check_lock(lp->ll_newkey == NULL
	1301	+ else if (value_check_lock(lp->ll_newkey == NULL
1301	1302	? lp->ll_tv->v_lock
1302	1303	: lp->ll_tv->vval.v_dict->dv_lock, lp->ll_name, FALSE))
1303	1304	;

		@@ -1317,7 +1318,7 @@
1317	1318	*/
1318	1319	for (ri = rettv->vval.v_list->lv_first; ri != NULL && ll_li != NULL; )
1319	1320	{
1320		- if (var_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
	1321	+ if (value_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
1321	1322	return;
1322	1323	ri = ri->li_next;
1323	1324	if (ri == NULL \|\| (!lp->ll_empty2 && lp->ll_n2 == ll_n1))

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/evalvars.c

--- a/src/evalvars.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/evalvars.c Wed Sep 16 21:15:05 2020 +0200

		@@ -1560,9 +1560,9 @@
1560	1560	*name_end = cc;
1561	1561	}
1562	1562	else if ((lp->ll_list != NULL
1563		- && var_check_lock(lp->ll_list->lv_lock, lp->ll_name, FALSE))
	1563	+ && value_check_lock(lp->ll_list->lv_lock, lp->ll_name, FALSE))
1564	1564	\|\| (lp->ll_dict != NULL
1565		- && var_check_lock(lp->ll_dict->dv_lock, lp->ll_name, FALSE)))
	1565	+ && value_check_lock(lp->ll_dict->dv_lock, lp->ll_name, FALSE)))
1566	1566	return FAIL;
1567	1567	else if (lp->ll_range)
1568	1568	{

		@@ -1573,7 +1573,7 @@
1573	1573	while (ll_li != NULL && (lp->ll_empty2 \|\| lp->ll_n2 >= ll_n1))
1574	1574	{
1575	1575	li = ll_li->li_next;
1576		- if (var_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
	1576	+ if (value_check_lock(ll_li->li_tv.v_lock, lp->ll_name, FALSE))
1577	1577	return FAIL;
1578	1578	ll_li = li;
1579	1579	++ll_n1;

		@@ -1646,7 +1646,7 @@
1646	1646	di = HI2DI(hi);
1647	1647	if (var_check_fixed(di->di_flags, name, FALSE)
1648	1648	\|\| var_check_ro(di->di_flags, name, FALSE)
1649		- \|\| var_check_lock(d->dv_lock, name, FALSE))
	1649	+ \|\| value_check_lock(d->dv_lock, name, FALSE))
1650	1650	return FAIL;
1651	1651
1652	1652	delete_var(ht, hi);

		@@ -1677,9 +1677,6 @@
1677	1677	int cc;
1678	1678	dictitem_T *di;
1679	1679
1680		- if (deep == 0) // nothing to do
1681		- return OK;
1682		-
1683	1680	if (lp->ll_tv == NULL)
1684	1681	{
1685	1682	cc = *name_end;

		@@ -1710,11 +1707,16 @@
1710	1707	di->di_flags \|= DI_FLAGS_LOCK;
1711	1708	else
1712	1709	di->di_flags &= ~DI_FLAGS_LOCK;
1713		- item_lock(&di->di_tv, deep, lock, FALSE);
	1710	+ if (deep != 0)
	1711	+ item_lock(&di->di_tv, deep, lock, FALSE);
1714	1712	}
1715	1713	}
1716	1714	*name_end = cc;
1717	1715	}
	1716	+ else if (deep == 0)
	1717	+ {
	1718	+ // nothing to do
	1719	+ }
1718	1720	else if (lp->ll_range)
1719	1721	{
1720	1722	listitem_T *li = lp->ll_li;

		@@ -3007,8 +3009,13 @@
3007	3009	goto failed;
3008	3010	}
3009	3011
	3012	+ // Check in this order for backwards compatibility:
	3013	+ // - Whether the variable is read-only
	3014	+ // - Whether the variable value is locked
	3015	+ // - Whether the variable is locked
3010	3016	if (var_check_ro(di->di_flags, name, FALSE)
3011		- \|\| var_check_lock(di->di_tv.v_lock, name, FALSE))
	3017	+ \|\| value_check_lock(di->di_tv.v_lock, name, FALSE)
	3018	+ \|\| var_check_lock(di->di_flags, name, FALSE))
3012	3019	goto failed;
3013	3020	}
3014	3021	else

		@@ -3158,6 +3165,22 @@
3158	3165	}
3159	3166
3160	3167	/*
	3168	+ * Return TRUE if di_flags "flags" indicates variable "name" is locked.
	3169	+ * Also give an error message.
	3170	+ */
	3171	+ int
	3172	+var_check_lock(int flags, char_u *name, int use_gettext)
	3173	+{
	3174	+ if (flags & DI_FLAGS_LOCK)
	3175	+ {
	3176	+ semsg(_(e_variable_is_locked_str),
	3177	+ use_gettext ? (char_u *)_(name) : name);
	3178	+ return TRUE;
	3179	+ }
	3180	+ return FALSE;
	3181	+}
	3182	+
	3183	+/*
3161	3184	* Return TRUE if di_flags "flags" indicates variable "name" is fixed.
3162	3185	* Also give an error message.
3163	3186	*/

		@@ -3204,12 +3227,12 @@
3204	3227	}
3205	3228
3206	3229	/*
3207		- * Return TRUE if "flags" indicates variable "name" is locked (immutable).
3208		- * Also give an error message, using "name" or _("name") when use_gettext is
3209		- * TRUE.
	3230	+ * Return TRUE if "flags" indicates variable "name" has a locked (immutable)
	3231	+ * value. Also give an error message, using "name" or _("name") when
	3232	+ * "use_gettext" is TRUE.
3210	3233	*/
3211	3234	int
3212		-var_check_lock(int lock, char_u *name, int use_gettext)
	3235	+value_check_lock(int lock, char_u *name, int use_gettext)
3213	3236	{
3214	3237	if (lock & VAR_LOCKED)
3215	3238	{

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/list.c

--- a/src/list.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/list.c Wed Sep 16 21:15:05 2020 +0200

		@@ -817,7 +817,7 @@
817	817	}
818	818
819	819	l = argvars[0].vval.v_list;
820		- if (l != NULL && !var_check_lock(l->lv_lock,
	820	+ if (l != NULL && !value_check_lock(l->lv_lock,
821	821	(char_u *)N_("flatten() argument"), TRUE)
822	822	&& list_flatten(l, maxdepth) == OK)
823	823	copy_tv(&argvars[0], rettv);

		@@ -1439,7 +1439,7 @@
1439	1439	int idx;
1440	1440
1441	1441	if ((l = argvars[0].vval.v_list) == NULL
1442		- \|\| var_check_lock(l->lv_lock, arg_errmsg, TRUE))
	1442	+ \|\| value_check_lock(l->lv_lock, arg_errmsg, TRUE))
1443	1443	return;
1444	1444
1445	1445	idx = (long)tv_get_number_chk(&argvars[1], &error);

		@@ -1687,7 +1687,7 @@
1687	1687	else
1688	1688	{
1689	1689	l = argvars[0].vval.v_list;
1690		- if (l == NULL \|\| var_check_lock(l->lv_lock,
	1690	+ if (l == NULL \|\| value_check_lock(l->lv_lock,
1691	1691	(char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),
1692	1692	TRUE))
1693	1693	goto theend;

		@@ -1955,13 +1955,13 @@
1955	1955	else if (argvars[0].v_type == VAR_LIST)
1956	1956	{
1957	1957	if ((l = argvars[0].vval.v_list) == NULL
1958		- \|\| (!map && var_check_lock(l->lv_lock, arg_errmsg, TRUE)))
	1958	+ \|\| (!map && value_check_lock(l->lv_lock, arg_errmsg, TRUE)))
1959	1959	return;
1960	1960	}
1961	1961	else if (argvars[0].v_type == VAR_DICT)
1962	1962	{
1963	1963	if ((d = argvars[0].vval.v_dict) == NULL
1964		- \|\| (!map && var_check_lock(d->dv_lock, arg_errmsg, TRUE)))
	1964	+ \|\| (!map && value_check_lock(d->dv_lock, arg_errmsg, TRUE)))
1965	1965	return;
1966	1966	}
1967	1967	else

		@@ -2004,7 +2004,7 @@
2004	2004
2005	2005	--todo;
2006	2006	di = HI2DI(hi);
2007		- if (map && (var_check_lock(di->di_tv.v_lock,
	2007	+ if (map && (value_check_lock(di->di_tv.v_lock,
2008	2008	arg_errmsg, TRUE)
2009	2009	\|\| var_check_ro(di->di_flags,
2010	2010	arg_errmsg, TRUE)))

		@@ -2077,7 +2077,7 @@
2077	2077	l->lv_lock = VAR_LOCKED;
2078	2078	for (li = l->lv_first; li != NULL; li = nli)
2079	2079	{
2080		- if (map && var_check_lock(li->li_tv.v_lock, arg_errmsg, TRUE))
	2080	+ if (map && value_check_lock(li->li_tv.v_lock, arg_errmsg, TRUE))
2081	2081	break;
2082	2082	nli = li->li_next;
2083	2083	set_vim_var_nr(VV_KEY, idx);

		@@ -2131,7 +2131,7 @@
2131	2131	if (argvars[0].v_type == VAR_LIST)
2132	2132	{
2133	2133	if ((l = argvars[0].vval.v_list) != NULL
2134		- && !var_check_lock(l->lv_lock,
	2134	+ && !value_check_lock(l->lv_lock,
2135	2135	(char_u *)N_("add() argument"), TRUE)
2136	2136	&& list_append_tv(l, &argvars[1]) == OK)
2137	2137	copy_tv(&argvars[0], rettv);

		@@ -2139,7 +2139,7 @@
2139	2139	else if (argvars[0].v_type == VAR_BLOB)
2140	2140	{
2141	2141	if ((b = argvars[0].vval.v_blob) != NULL
2142		- && !var_check_lock(b->bv_lock,
	2142	+ && !value_check_lock(b->bv_lock,
2143	2143	(char_u *)N_("add() argument"), TRUE))
2144	2144	{
2145	2145	int error = FALSE;

		@@ -2282,7 +2282,7 @@
2282	2282
2283	2283	l1 = argvars[0].vval.v_list;
2284	2284	l2 = argvars[1].vval.v_list;
2285		- if (l1 != NULL && !var_check_lock(l1->lv_lock, arg_errmsg, TRUE)
	2285	+ if (l1 != NULL && !value_check_lock(l1->lv_lock, arg_errmsg, TRUE)
2286	2286	&& l2 != NULL)
2287	2287	{
2288	2288	if (argvars[2].v_type != VAR_UNKNOWN)

		@@ -2318,7 +2318,7 @@
2318	2318
2319	2319	d1 = argvars[0].vval.v_dict;
2320	2320	d2 = argvars[1].vval.v_dict;
2321		- if (d1 != NULL && !var_check_lock(d1->dv_lock, arg_errmsg, TRUE)
	2321	+ if (d1 != NULL && !value_check_lock(d1->dv_lock, arg_errmsg, TRUE)
2322	2322	&& d2 != NULL)
2323	2323	{
2324	2324	// Check the third argument.

		@@ -2402,7 +2402,7 @@
2402	2402	else if (argvars[0].v_type != VAR_LIST)
2403	2403	semsg(_(e_listblobarg), "insert()");
2404	2404	else if ((l = argvars[0].vval.v_list) != NULL
2405		- && !var_check_lock(l->lv_lock,
	2405	+ && !value_check_lock(l->lv_lock,
2406	2406	(char_u *)N_("insert() argument"), TRUE))
2407	2407	{
2408	2408	if (argvars[2].v_type != VAR_UNKNOWN)

		@@ -2475,7 +2475,7 @@
2475	2475	if (argvars[0].v_type != VAR_LIST)
2476	2476	semsg(_(e_listblobarg), "reverse()");
2477	2477	else if ((l = argvars[0].vval.v_list) != NULL
2478		- && !var_check_lock(l->lv_lock,
	2478	+ && !value_check_lock(l->lv_lock,
2479	2479	(char_u *)N_("reverse() argument"), TRUE))
2480	2480	{
2481	2481	if (l->lv_first == &range_list_item)

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/proto/evalvars.pro

--- a/src/proto/evalvars.pro Wed Sep 16 18:00:04 2020 +0200

+++ b/src/proto/evalvars.pro Wed Sep 16 21:15:05 2020 +0200

		@@ -68,9 +68,10 @@
68	68	void set_var(char_u name, typval_T tv, int copy);
69	69	void set_var_const(char_u name, type_T type, typval_T *tv_arg, int copy, int flags);
70	70	int var_check_ro(int flags, char_u *name, int use_gettext);
	71	+int var_check_lock(int flags, char_u *name, int use_gettext);
71	72	int var_check_fixed(int flags, char_u *name, int use_gettext);
72	73	int var_wrong_func_name(char_u *name, int new_var);
73		-int var_check_lock(int lock, char_u *name, int use_gettext);
	74	+int value_check_lock(int lock, char_u *name, int use_gettext);
74	75	int valid_varname(char_u *varname);
75	76	void reset_v_option_vars(void);
76	77	void assert_error(garray_T *gap);

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/testdir/test_const.vim

--- a/src/testdir/test_const.vim Wed Sep 16 18:00:04 2020 +0200

+++ b/src/testdir/test_const.vim Wed Sep 16 21:15:05 2020 +0200

		@@ -215,6 +215,14 @@
215	215
216	216	if 0 \| lockvar x \| endif
217	217	let x = 'again'
	218	+
	219	+ let val = [1, 2, 3]
	220	+ lockvar 0 val
	221	+ let val[0] = 9
	222	+ call assert_equal([9, 2, 3], val)
	223	+ call add(val, 4)
	224	+ call assert_equal([9, 2, 3, 4], val)
	225	+ call assert_fails('let val = [4, 5, 6]', 'E1122:')
218	226	endfunc
219	227
220	228

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/testdir/test_listdict.vim

--- a/src/testdir/test_listdict.vim Wed Sep 16 18:00:04 2020 +0200

+++ b/src/testdir/test_listdict.vim Wed Sep 16 21:15:05 2020 +0200

		@@ -354,7 +354,7 @@
354	354	" Locked variables
355	355	func Test_list_locked_var()
356	356	let expected = [
357		- \ [['0000-000', 'ppppppp'],
	357	+ \ [['1000-000', 'ppppppF'],
358	358	\ ['0000-000', 'ppppppp'],
359	359	\ ['0000-000', 'ppppppp']],
360	360	\ [['1000-000', 'ppppppF'],

		@@ -381,7 +381,7 @@
381	381	exe "unlockvar " . depth . " l"
382	382	endif
383	383	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]")
384		- call assert_equal(expected[depth][u][0], ps)
	384	+ call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
385	385	let ps = ''
386	386	try
387	387	let l[1][1][0] = 99

		@@ -425,7 +425,7 @@
425	425	catch
426	426	let ps .= 'F'
427	427	endtry
428		- call assert_equal(expected[depth][u][1], ps)
	428	+ call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth)
429	429	endfor
430	430	endfor
431	431	call assert_fails("let x=islocked('a b')", 'E488:')

		@@ -438,7 +438,7 @@
438	438	" Unletting locked variables
439	439	func Test_list_locked_var_unlet()
440	440	let expected = [
441		- \ [['0000-000', 'ppppppp'],
	441	+ \ [['1000-000', 'ppppppp'],
442	442	\ ['0000-000', 'ppppppp'],
443	443	\ ['0000-000', 'ppppppp']],
444	444	\ [['1000-000', 'ppFppFp'],

		@@ -466,7 +466,7 @@
466	466	exe "unlockvar " . depth . " l"
467	467	endif
468	468	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]")
469		- call assert_equal(expected[depth][u][0], ps)
	469	+ call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth)
470	470	let ps = ''
471	471	try
472	472	unlet l[2]['6'][7]

		@@ -666,6 +666,9 @@
666	666	call s:arg_list_test(1, 2, [3, 4], {5: 6})
667	667	endfunc
668	668
	669	+func Test_dict_item_locked()
	670	+endfunc
	671	+
669	672	" Tests for reverse(), sort(), uniq()
670	673	func Test_reverse_sort_uniq()
671	674	let l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5]

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/typval.c

--- a/src/typval.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/typval.c Wed Sep 16 21:15:05 2020 +0200

		@@ -512,8 +512,8 @@
512	512	default:
513	513	break;
514	514	}
515		- return var_check_lock(tv->v_lock, name, use_gettext)
516		- \|\| (lock != 0 && var_check_lock(lock, name, use_gettext));
	515	+ return value_check_lock(tv->v_lock, name, use_gettext)
	516	+ \|\| (lock != 0 && value_check_lock(lock, name, use_gettext));
517	517	}
518	518
519	519	/*

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/userfunc.c

--- a/src/userfunc.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/userfunc.c Wed Sep 16 21:15:05 2020 +0200

		@@ -3346,11 +3346,11 @@
3346	3346	if (fudi.fd_di == NULL)
3347	3347	{
3348	3348	// Can't add a function to a locked dictionary
3349		- if (var_check_lock(fudi.fd_dict->dv_lock, eap->arg, FALSE))
	3349	+ if (value_check_lock(fudi.fd_dict->dv_lock, eap->arg, FALSE))
3350	3350	goto erret;
3351	3351	}
3352	3352	// Can't change an existing function if it is locked
3353		- else if (var_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg, FALSE))
	3353	+ else if (value_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg, FALSE))
3354	3354	goto erret;
3355	3355
3356	3356	// Give the function a sequential number. Can only be used with a

diff -r 3d2dc70119a7 -r 07e48ee8c3bb src/version.c

--- a/src/version.c Wed Sep 16 18:00:04 2020 +0200

+++ b/src/version.c Wed Sep 16 21:15:05 2020 +0200

		@@ -751,6 +751,8 @@
751	751	static int included_patches[] =
752	752	{ /* Add new patch number below this line */
753	753	/**/
	754	+ 1698,
	755	+/**/
754	756	1697,
755	757	/**/
756	758	1696,

Show on old repository browser