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

Merge #6112 from ZyX-I/split-eval'/buf_get_changedtick

Browse Source 
Better b:changedtick support
This commit is contained in:
Justin M. Keyes
2017-02-27 10:29:46 +01:00
committed by GitHub
parent 8c8ce1832e a85021068d
commit c318d8e672
27 changed files with 688 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

585
src/nvim/eval.c
View File

@@ -171,6 +171,8 @@ static char *e_letwrong = N_("E734: Wrong variable type for %s=");
static char *e_nofunc = N_("E130: Unknown function: %s");
static char *e_illvar = N_("E461: Illegal variable name: %s");
static char *e_float_as_string = N_("E806: using Float as a String");
static const char *e_readonlyvar = N_(
"E46: Cannot change read-only variable \"%.*s\"");
static char_u * const empty_string = (char_u *)"";
static char_u * const namespace_char = (char_u *)"abglstvw";
@@ -201,15 +203,22 @@ static garray_T ga_scripts = {0, 0, sizeof(scriptvar_T *), 4, NULL};
static int echo_attr = 0; /* attributes used for ":echo" */
// Values for trans_function_name() argument:
#define TFN_INT 1 // internal function name OK
#define TFN_QUIET 2 // no error messages
#define TFN_NO_AUTOLOAD 4 // do not use script autoloading
#define TFN_NO_DEREF 8 // do not dereference a Funcref
/// trans_function_name() flags
typedef enum {
TFN_INT = 1, ///< May use internal function name
TFN_QUIET = 2, ///< Do not emit error messages.
TFN_NO_AUTOLOAD = 4, ///< Do not use script autoloading.
TFN_NO_DEREF = 8, ///< Do not dereference a Funcref.
TFN_READ_ONLY = 16, ///< Will not change the variable.
} TransFunctionNameFlags;
// Values for get_lval() flags argument:
#define GLV_QUIET TFN_QUIET // no error messages
#define GLV_NO_AUTOLOAD TFN_NO_AUTOLOAD // do not use script autoloading
/// get_lval() flags
typedef enum {
GLV_QUIET = TFN_QUIET, ///< Do not emit error messages.
GLV_NO_AUTOLOAD = TFN_NO_AUTOLOAD, ///< Do not use script autoloading.
GLV_READ_ONLY = TFN_READ_ONLY, ///< Indicates that caller will not change
///< the value (prevents error message).
} GetLvalFlags;
// function flags
#define FC_ABORT 0x01 // abort function on error
@@ -541,8 +550,8 @@ void eval_init(void)
list_T *const type_list = list_alloc();
type_list->lv_lock = VAR_FIXED;
type_list->lv_refcount = 1;
dictitem_T *const di = dictitem_alloc((char_u *) msgpack_type_names[i]);
di->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
dictitem_T *const di = dictitem_alloc((char_u *)msgpack_type_names[i]);
di->di_flags |= DI_FLAGS_RO|DI_FLAGS_FIX;
di->di_tv = (typval_T) {
.v_type = VAR_LIST,
.vval = { .v_list = type_list, },
@@ -1646,13 +1655,7 @@ static void list_glob_vars(int *first)
*/
static void list_buf_vars(int *first)
{
char numbuf[NUMBUFLEN];
list_hashtable_vars(&curbuf->b_vars->dv_hashtab, "b:", true, first);
snprintf(numbuf, sizeof(numbuf), "%d", curbuf->b_changedtick);
list_one_var_a("b:", "changedtick", sizeof("changedtick") - 1, VAR_NUMBER,
numbuf, first);
}
/*
@@ -1949,46 +1952,33 @@ ex_let_one (
return arg_end;
}
/*
* If "arg" is equal to "b:changedtick" give an error and return TRUE.
*/
static int check_changedtick(char_u *arg)
{
if (STRNCMP(arg, "b:changedtick", 13) == 0 && !eval_isnamec(arg[13])) {
EMSG2(_(e_readonlyvar), arg);
return TRUE;
}
return FALSE;
}
/*
* Get an lval: variable, Dict item or List item that can be assigned a value
* to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
* "name.key", "name.key[expr]" etc.
* Indexing only works if "name" is an existing List or Dictionary.
* "name" points to the start of the name.
* If "rettv" is not NULL it points to the value to be assigned.
* "unlet" is TRUE for ":unlet": slightly different behavior when something is
* wrong; must end in space or cmd separator.
*
* flags:
* GLV_QUIET: do not give error messages
* GLV_NO_AUTOLOAD: do not use script autoloading
*
* Returns a pointer to just after the name, including indexes.
* When an evaluation error occurs "lp->ll_name" is NULL;
* Returns NULL for a parsing error. Still need to free items in "lp"!
*/
static char_u *
get_lval (
char_u *name,
typval_T *rettv,
lval_T *lp,
int unlet,
int skip,
int flags, /* GLV_ values */
int fne_flags /* flags for find_name_end() */
)
/// Get an lvalue
///
/// Lvalue may be
/// - variable: "name", "na{me}"
/// - dictionary item: "dict.key", "dict['key']"
/// - list item: "list[expr]"
/// - list slice: "list[expr:expr]"
///
/// Indexing only works if trying to use it with an existing List or Dictionary.
///
/// @param[in] name Name to parse.
/// @param rettv Pointer to the value to be assigned or NULL.
/// @param[out] lp Lvalue definition. When evaluation errors occur `->ll_name`
/// is NULL.
/// @param[in] unlet True if using `:unlet`. This results in slightly
/// different behaviour when something is wrong; must end in
/// space or cmd separator.
/// @param[in] skip True when skipping.
/// @param[in] flags @see GetLvalFlags.
/// @param[in] fne_flags Flags for find_name_end().
///
/// @return A pointer to just after the name, including indexes. Returns NULL
/// for a parsing error, but it is still needed to free items in lp.
static char_u *get_lval(char_u *const name, typval_T *const rettv,
lval_T *const lp, const bool unlet, const bool skip,
const int flags, const int fne_flags)
FUNC_ATTR_NONNULL_ARG(1, 3)
{
char_u *p;
char_u *expr_start, *expr_end;
@@ -2207,8 +2197,13 @@ get_lval (
if (len == -1)
clear_tv(&var1);
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 (!(flags & GLV_READ_ONLY) && var_check_ro(lp->ll_di->di_flags,
(const char *)name,
(size_t)(p - name))) {
if (len == -1) {
clear_tv(&var1);
}
return NULL;
}
@@ -2299,32 +2294,33 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
dictitem_T *di;
if (lp->ll_tv == NULL) {
if (!check_changedtick(lp->ll_name)) {
cc = *endp;
*endp = NUL;
if (op != NULL && *op != '=') {
typval_T tv;
cc = *endp;
*endp = NUL;
if (op != NULL && *op != '=') {
typval_T tv;
// handle +=, -= and .=
di = NULL;
if (get_var_tv((const char *)lp->ll_name, (int)STRLEN(lp->ll_name),
&tv, &di, true, false) == OK) {
if ((di == NULL
|| (!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);
// handle +=, -= and .=
di = NULL;
if (get_var_tv((const char *)lp->ll_name, (int)STRLEN(lp->ll_name),
&tv, &di, true, false) == OK) {
if ((di == NULL
|| (!var_check_ro(di->di_flags, (const char *)lp->ll_name,
STRLEN(lp->ll_name))
&& !tv_check_lock(di->di_tv.v_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name))))
&& tv_op(&tv, rettv, op) == OK) {
set_var(lp->ll_name, &tv, false);
}
} else
set_var(lp->ll_name, rettv, copy);
*endp = cc;
clear_tv(&tv);
}
} else {
set_var(lp->ll_name, rettv, copy);
}
*endp = cc;
} else if (tv_check_lock(lp->ll_newkey == NULL
? lp->ll_tv->v_lock
: lp->ll_tv->vval.v_dict->dv_lock,
lp->ll_name, false)) {
(const char *)lp->ll_name, STRLEN(lp->ll_name))) {
} else if (lp->ll_range) {
listitem_T *ll_li = lp->ll_li;
int ll_n1 = lp->ll_n1;
@@ -2332,7 +2328,8 @@ static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, ch
// Check whether any of the list items is locked
for (listitem_T *ri = rettv->vval.v_list->lv_first;
ri != NULL && ll_li != NULL; ) {
if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, false)) {
if (tv_check_lock(ll_li->li_tv.v_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name))) {
return;
}
ri = ri->li_next;
@@ -2938,16 +2935,18 @@ static int do_unlet_var(lval_T *lp, char_u *name_end, int forceit)
cc = *name_end;
*name_end = NUL;
/* Normal name or expanded name. */
if (check_changedtick(lp->ll_name))
ret = FAIL;
else if (do_unlet(lp->ll_name, forceit) == FAIL)
// Normal name or expanded name.
if (do_unlet(lp->ll_name, forceit) == FAIL) {
ret = FAIL;
}
*name_end = cc;
} else if ((lp->ll_list != NULL
&& tv_check_lock(lp->ll_list->lv_lock, lp->ll_name, false))
&& tv_check_lock(lp->ll_list->lv_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name)))
|| (lp->ll_dict != NULL
&& tv_check_lock(lp->ll_dict->dv_lock, lp->ll_name, false))) {
&& tv_check_lock(lp->ll_dict->dv_lock,
(const char *)lp->ll_name,
STRLEN(lp->ll_name)))) {
return FAIL;
} else if (lp->ll_range) {
listitem_T *li;
@@ -2956,7 +2955,8 @@ 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)) {
li = ll_li->li_next;
if (tv_check_lock(ll_li->li_tv.v_lock, lp->ll_name, false)) {
if (tv_check_lock(ll_li->li_tv.v_lock, (const char *)lp->ll_name,
STRLEN(lp->ll_name))) {
return false;
}
ll_li = li;
@@ -3038,13 +3038,14 @@ int do_unlet(char_u *name, int forceit)
}
if (hi != NULL && !HASHITEM_EMPTY(hi)) {
di = HI2DI(hi);
if (var_check_fixed(di->di_flags, name, false)
|| var_check_ro(di->di_flags, name, false)
|| tv_check_lock(d->dv_lock, name, false)) {
if (var_check_fixed(di->di_flags, (const char *)name, STRLEN(name))
|| var_check_ro(di->di_flags, (const char *)name, STRLEN(name))
|| tv_check_lock(d->dv_lock, (const char *)name, STRLEN(name))) {
return FAIL;
}
if (d == NULL || tv_check_lock(d->dv_lock, name, false)) {
if (d == NULL
|| tv_check_lock(d->dv_lock, (const char *)name, STRLEN(name))) {
return FAIL;
}
@@ -3078,33 +3079,33 @@ int do_unlet(char_u *name, int forceit)
static int do_lock_var(lval_T *lp, char_u *name_end, int deep, int lock)
{
int ret = OK;
int cc;
dictitem_T *di;
if (deep == 0) /* nothing to do */
if (deep == 0) { // Nothing to do.
return OK;
}
if (lp->ll_tv == NULL) {
cc = *name_end;
*name_end = NUL;
// Normal name or expanded name.
if (check_changedtick(lp->ll_name)) {
const size_t name_len = (size_t)(name_end - lp->ll_name);
dictitem_T *const di = find_var(
(const char *)lp->ll_name, name_len, NULL,
true);
if (di == NULL) {
ret = FAIL;
} else if ((di->di_flags & DI_FLAGS_FIX)
&& di->di_tv.v_type != VAR_DICT
&& di->di_tv.v_type != VAR_LIST) {
// For historical reasons this error is not given for Lists and
// Dictionaries. E.g. b: dictionary may be locked/unlocked.
emsgf(_("E940: Cannot lock or unlock variable %s"), lp->ll_name);
} else {
di = find_var((const char *)lp->ll_name, STRLEN(lp->ll_name), NULL, true);
if (di == NULL) {
ret = FAIL;
if (lock) {
di->di_flags |= DI_FLAGS_LOCK;
} else {
if (lock) {
di->di_flags |= DI_FLAGS_LOCK;
} else {
di->di_flags &= ~DI_FLAGS_LOCK;
}
item_lock(&di->di_tv, deep, lock);
di->di_flags &= ~DI_FLAGS_LOCK;
}
item_lock(&di->di_tv, deep, lock);
}
*name_end = cc;
} else if (lp->ll_range) {
listitem_T *li = lp->ll_li;
@@ -3131,68 +3132,72 @@ static int do_lock_var(lval_T *lp, char_u *name_end, int deep, int lock)
static void item_lock(typval_T *tv, int deep, int lock)
{
static int recurse = 0;
list_T *l;
listitem_T *li;
dict_T *d;
hashitem_T *hi;
int todo;
if (recurse >= DICT_MAXNEST) {
EMSG(_("E743: variable nested too deep for (un)lock"));
return;
}
if (deep == 0)
if (deep == 0) {
return;
++recurse;
}
recurse++;
/* lock/unlock the item itself */
if (lock)
tv->v_lock |= VAR_LOCKED;
else
tv->v_lock &= ~VAR_LOCKED;
// lock/unlock the item itself
#define CHANGE_LOCK(var, lock) \
do { \
var = ((VarLockStatus[]) { \
[VAR_UNLOCKED] = (lock ? VAR_LOCKED : VAR_UNLOCKED), \
[VAR_LOCKED] = (lock ? VAR_LOCKED : VAR_UNLOCKED), \
[VAR_FIXED] = VAR_FIXED, \
})[var]; \
} while (0)
CHANGE_LOCK(tv->v_lock, lock);
switch (tv->v_type) {
case VAR_LIST:
if ((l = tv->vval.v_list) != NULL) {
if (lock)
l->lv_lock |= VAR_LOCKED;
else
l->lv_lock &= ~VAR_LOCKED;
if (deep < 0 || deep > 1)
/* recursive: lock/unlock the items the List contains */
for (li = l->lv_first; li != NULL; li = li->li_next)
item_lock(&li->li_tv, deep - 1, lock);
}
break;
case VAR_DICT:
if ((d = tv->vval.v_dict) != NULL) {
if (lock)
d->dv_lock |= VAR_LOCKED;
else
d->dv_lock &= ~VAR_LOCKED;
if (deep < 0 || deep > 1) {
/* recursive: lock/unlock the items the List contains */
todo = (int)d->dv_hashtab.ht_used;
for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi) {
if (!HASHITEM_EMPTY(hi)) {
--todo;
item_lock(&HI2DI(hi)->di_tv, deep - 1, lock);
case VAR_LIST: {
list_T *const l = tv->vval.v_list;
if (l != NULL) {
CHANGE_LOCK(l->lv_lock, lock);
if (deep < 0 || deep > 1) {
// Recursive: lock/unlock the items the List contains.
for (listitem_T *li = l->lv_first; li != NULL; li = li->li_next) {
item_lock(&li->li_tv, deep - 1, lock);
}
}
}
break;
}
case VAR_DICT: {
dict_T *const d = tv->vval.v_dict;
if (d != NULL) {
CHANGE_LOCK(d->dv_lock, lock);
if (deep < 0 || deep > 1) {
// Recursive: lock/unlock the items the List contains.
int todo = (int)d->dv_hashtab.ht_used;
for (hashitem_T *hi = d->dv_hashtab.ht_array; todo > 0; hi++) {
if (!HASHITEM_EMPTY(hi)) {
todo--;
item_lock(&HI2DI(hi)->di_tv, deep - 1, lock);
}
}
}
}
break;
}
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_STRING:
case VAR_FUNC:
case VAR_PARTIAL:
case VAR_SPECIAL: {
break;
}
case VAR_UNKNOWN: {
assert(false);
}
break;
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_STRING:
case VAR_FUNC:
case VAR_PARTIAL:
case VAR_SPECIAL:
break;
case VAR_UNKNOWN:
assert(false);
}
--recurse;
#undef CHANGE_LOCK
recurse--;
}
/*
@@ -3302,10 +3307,6 @@ char_u *get_user_var_name(expand_T *xp, int idx)
++hi;
return cat_prefix_varname('b', hi->hi_key);
}
if (bdone == ht->ht_used) {
++bdone;
return (char_u *)"b:changedtick";
}
/* w: variables */
ht = &curwin->w_vars->dv_hashtab;
@@ -6373,7 +6374,7 @@ dict_T *dict_alloc(void) FUNC_ATTR_NONNULL_RET
first_dict = d;
hash_init(&d->dv_hashtab);
d->dv_lock = 0;
d->dv_lock = VAR_UNLOCKED;
d->dv_scope = 0;
d->dv_refcount = 0;
d->dv_copyID = 0;
@@ -6446,9 +6447,8 @@ static void dict_free_contents(dict_T *d) {
* something recursive causing trouble. */
di = HI2DI(hi);
hash_remove(&d->dv_hashtab, hi);
clear_tv(&di->di_tv);
xfree(di);
--todo;
dictitem_free(di);
todo--;
}
}
@@ -7820,9 +7820,10 @@ static void f_add(typval_T *argvars, typval_T *rettv, FunPtr fptr)
rettv->vval.v_number = 1; /* Default: Failed */
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
&& !tv_check_lock(l->lv_lock,
(char_u *)N_("add() argument"), true)) {
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
list_append_tv(l, &argvars[1]);
copy_tv(&argvars[0], rettv);
}
@@ -9399,7 +9400,8 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
hashitem_T *hi2;
int todo;
bool watched = is_watched(d1);
char_u *arg_errmsg = (char_u *)N_("extend() argument");
const char *const arg_errmsg = _("extend() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
todo = (int)d2->dv_hashtab.ht_used;
for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2) {
@@ -9433,8 +9435,8 @@ 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, arg_errmsg, true)
|| var_check_ro(di1->di_flags, arg_errmsg, true)) {
if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
|| var_check_ro(di1->di_flags, arg_errmsg, arg_errmsg_len)) {
break;
}
@@ -9460,7 +9462,8 @@ void dict_extend(dict_T *d1, dict_T *d2, char_u *action)
*/
static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
char_u *arg_errmsg = (char_u *)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) {
list_T *l1, *l2;
@@ -9470,7 +9473,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
l1 = argvars[0].vval.v_list;
l2 = argvars[1].vval.v_list;
if (l1 != NULL && !tv_check_lock(l1->lv_lock, arg_errmsg, true)
if (l1 != NULL && !tv_check_lock(l1->lv_lock, arg_errmsg, arg_errmsg_len)
&& l2 != NULL) {
if (argvars[2].v_type != VAR_UNKNOWN) {
before = get_tv_number_chk(&argvars[2], &error);
@@ -9500,7 +9503,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
d1 = argvars[0].vval.v_dict;
d2 = argvars[1].vval.v_dict;
if (d1 != NULL && !tv_check_lock(d1->dv_lock, arg_errmsg, true)
if (d1 != NULL && !tv_check_lock(d1->dv_lock, arg_errmsg, arg_errmsg_len)
&& d2 != NULL) {
/* Check the third argument. */
if (argvars[2].v_type != VAR_UNKNOWN) {
@@ -9643,20 +9646,22 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
typval_T save_key;
int rem = false;
int todo;
char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
char_u *arg_errmsg = (char_u *)(map ? N_("map() argument")
: N_("filter() argument"));
char_u *ermsg = (char_u *)(map ? "map()" : "filter()");
const char *const arg_errmsg = (map
? _("map() argument")
: _("filter() argument"));
const size_t arg_errmsg_len = strlen(arg_errmsg);
int save_did_emsg;
int idx = 0;
if (argvars[0].v_type == VAR_LIST) {
if ((l = argvars[0].vval.v_list) == NULL
|| (!map && tv_check_lock(l->lv_lock, arg_errmsg, true))) {
|| (!map && tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len))) {
return;
}
} else if (argvars[0].v_type == VAR_DICT) {
if ((d = argvars[0].vval.v_dict) == NULL
|| (!map && tv_check_lock(d->dv_lock, arg_errmsg, true))) {
|| (!map && tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len))) {
return;
}
} else {
@@ -9689,8 +9694,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
di = HI2DI(hi);
if (map
&& (tv_check_lock(di->di_tv.v_lock, arg_errmsg, true)
|| var_check_ro(di->di_flags, arg_errmsg, true))) {
&& (tv_check_lock(di->di_tv.v_lock, arg_errmsg, arg_errmsg_len)
|| var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len))) {
break;
}
@@ -9700,8 +9705,8 @@ static void filter_map(typval_T *argvars, typval_T *rettv, int map)
if (r == FAIL || did_emsg)
break;
if (!map && rem) {
if (var_check_fixed(di->di_flags, arg_errmsg, true)
|| var_check_ro(di->di_flags, arg_errmsg, true)) {
if (var_check_fixed(di->di_flags, arg_errmsg, arg_errmsg_len)
|| var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) {
break;
}
dictitem_remove(d, di);
@@ -9713,7 +9718,8 @@ 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 (map && tv_check_lock(li->li_tv.v_lock, arg_errmsg, true)) {
if (map
&& tv_check_lock(li->li_tv.v_lock, arg_errmsg, arg_errmsg_len)) {
break;
}
nli = li->li_next;
@@ -10524,10 +10530,6 @@ static void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
// buffer-local-option
done = true;
}
} else if (STRCMP(varname, "changedtick") == 0) {
rettv->v_type = VAR_NUMBER;
rettv->vval.v_number = curbuf->b_changedtick;
done = true;
} else {
// Look up the variable.
// Let getbufvar({nr}, "") return the "b:" dictionary.
@@ -12395,13 +12397,14 @@ static void f_insert(typval_T *argvars, typval_T *rettv, FunPtr fptr)
long before = 0;
listitem_T *item;
list_T *l;
int error = FALSE;
int 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) {
EMSG2(_(e_listarg), "insert()");
} else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock,
(char_u *)N_("insert() argument"), true)) {
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
if (argvars[2].v_type != VAR_UNKNOWN) {
before = get_tv_number_chk(&argvars[2], &error);
}
@@ -12452,38 +12455,33 @@ static void f_islocked(typval_T *argvars, typval_T *rettv, FunPtr fptr)
dictitem_T *di;
rettv->vval.v_number = -1;
end = get_lval(get_tv_string(&argvars[0]), NULL, &lv, FALSE, FALSE,
GLV_NO_AUTOLOAD, FNE_CHECK_START);
end = get_lval(get_tv_string(&argvars[0]), NULL, &lv, false, false,
GLV_NO_AUTOLOAD|GLV_READ_ONLY, FNE_CHECK_START);
if (end != NULL && lv.ll_name != NULL) {
if (*end != NUL)
EMSG(_(e_trailing));
else {
if (lv.ll_tv == NULL) {
if (check_changedtick(lv.ll_name)) {
rettv->vval.v_number = 1; // Always locked.
} else {
di = find_var((const char *)lv.ll_name, STRLEN(lv.ll_name), NULL,
true);
if (di != NULL) {
/* Consider a variable locked when:
* 1. the variable itself is locked
* 2. the value of the variable is locked.
* 3. the List or Dict value is locked.
*/
rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
|| tv_islocked(&di->di_tv));
}
di = find_var((const char *)lv.ll_name, STRLEN(lv.ll_name), NULL, true);
if (di != NULL) {
// Consider a variable locked when:
// 1. the variable itself is locked
// 2. the value of the variable is locked.
// 3. the List or Dict value is locked.
rettv->vval.v_number = ((di->di_flags & DI_FLAGS_LOCK)
|| tv_islocked(&di->di_tv));
}
} else if (lv.ll_range)
} else if (lv.ll_range) {
EMSG(_("E786: Range not allowed"));
else if (lv.ll_newkey != NULL)
} else if (lv.ll_newkey != NULL) {
EMSG2(_(e_dictkey), lv.ll_newkey);
else if (lv.ll_list != NULL)
/* List item. */
} else if (lv.ll_list != NULL) {
// List item.
rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
else
/* Dictionary item. */
} else {
// Dictionary item.
rettv->vval.v_number = tv_islocked(&lv.ll_di->di_tv);
}
}
}
@@ -14430,20 +14428,21 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
char_u *key;
dict_T *d;
dictitem_T *di;
char_u *arg_errmsg = (char_u *)N_("remove() argument");
const char *const arg_errmsg = _("remove() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type == VAR_DICT) {
if (argvars[2].v_type != VAR_UNKNOWN) {
EMSG2(_(e_toomanyarg), "remove()");
} else if ((d = argvars[0].vval.v_dict) != NULL
&& !tv_check_lock(d->dv_lock, arg_errmsg, true)) {
&& !tv_check_lock(d->dv_lock, arg_errmsg, arg_errmsg_len)) {
key = get_tv_string_chk(&argvars[1]);
if (key != NULL) {
di = dict_find(d, key, -1);
if (di == NULL) {
EMSG2(_(e_dictkey), key);
} else if (!var_check_fixed(di->di_flags, arg_errmsg, true)
&& !var_check_ro(di->di_flags, arg_errmsg, true)) {
} else if (!var_check_fixed(di->di_flags, arg_errmsg, arg_errmsg_len)
&& !var_check_ro(di->di_flags, arg_errmsg, arg_errmsg_len)) {
*rettv = di->di_tv;
init_tv(&di->di_tv);
dictitem_remove(d, di);
@@ -14456,7 +14455,7 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
} else if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listdictarg), "remove()");
} else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock, arg_errmsg, true)) {
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
int error = (int)false;
idx = get_tv_number_chk(&argvars[1], &error);
@@ -14727,19 +14726,19 @@ fail:
*/
static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
list_T *l;
listitem_T *li, *ni;
const char *const arg_errmsg = _("reverse() argument");
const size_t arg_errmsg_len = strlen(arg_errmsg);
list_T *l;
if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listarg), "reverse()");
} else if ((l = argvars[0].vval.v_list) != NULL
&& !tv_check_lock(l->lv_lock,
(char_u *)N_("reverse() argument"), true)) {
li = l->lv_last;
&& !tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
listitem_T *li = l->lv_last;
l->lv_first = l->lv_last = NULL;
l->lv_len = 0;
while (li != NULL) {
ni = li->li_prev;
listitem_T *const ni = li->li_prev;
list_append(l, li);
li = ni;
}
@@ -16384,16 +16383,17 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
sortinfo_T *old_sortinfo = sortinfo;
sortinfo = &info;
const char *const arg_errmsg = (sort
? _("sort() argument")
: _("uniq() argument"));
const size_t arg_errmsg_len = strlen(arg_errmsg);
if (argvars[0].v_type != VAR_LIST) {
EMSG2(_(e_listarg), sort ? "sort()" : "uniq()");
} else {
l = argvars[0].vval.v_list;
if (l == NULL
|| tv_check_lock(l->lv_lock,
(char_u *)(sort
? N_("sort() argument")
: N_("uniq() argument")),
true)) {
|| tv_check_lock(l->lv_lock, arg_errmsg, arg_errmsg_len)) {
goto theend;
}
rettv->vval.v_list = l;
@@ -17732,10 +17732,10 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
(void)setfname(curbuf, (uint8_t *)buf, NULL, true);
// Save the job id and pid in b:terminal_job_{id,pid}
Error err;
dict_set_value(curbuf->b_vars, cstr_as_string("terminal_job_id"),
INTEGER_OBJ(rettv->vval.v_number), false, false, &err);
dict_set_value(curbuf->b_vars, cstr_as_string("terminal_job_pid"),
INTEGER_OBJ(pid), false, false, &err);
dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_id"),
INTEGER_OBJ(rettv->vval.v_number), false, false, &err);
dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_pid"),
INTEGER_OBJ(pid), false, false, &err);
Terminal *term = terminal_open(topts);
data->term = term;
@@ -19382,23 +19382,13 @@ static int get_var_tv(
{
int ret = OK;
typval_T *tv = NULL;
typval_T atv;
dictitem_T *v;
// Check for "b:changedtick".
if (sizeof("b:changedtick") - 1 == len
&& STRNCMP(name, "b:changedtick", len) == 0) {
atv.v_type = VAR_NUMBER;
atv.vval.v_number = curbuf->b_changedtick;
tv = &atv;
} else {
// Check for user-defined variables.
v = find_var(name, (size_t)len, NULL, no_autoload);
if (v != NULL) {
tv = &v->di_tv;
if (dip != NULL) {
*dip = v;
}
v = find_var(name, (size_t)len, NULL, no_autoload);
if (v != NULL) {
tv = &v->di_tv;
if (dip != NULL) {
*dip = v;
}
}
@@ -20381,7 +20371,7 @@ void new_script_vars(scid_T id)
void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope)
{
hash_init(&dict->dv_hashtab);
dict->dv_lock = 0;
dict->dv_lock = VAR_UNLOCKED;
dict->dv_scope = scope;
dict->dv_refcount = DO_NOT_FREE_CNT;
dict->dv_copyID = 0;
@@ -20557,8 +20547,8 @@ set_var (
if (v != NULL) {
// existing variable, need to clear the value
if (var_check_ro(v->di_flags, name, false)
|| tv_check_lock(v->di_tv.v_lock, name, false)) {
if (var_check_ro(v->di_flags, (const char *)name, name_len)
|| tv_check_lock(v->di_tv.v_lock, (const char *)name, name_len)) {
return;
}
@@ -20631,28 +20621,47 @@ set_var (
}
}
// Return true if di_flags "flags" indicates variable "name" is read-only.
// Also give an error message.
static bool var_check_ro(int flags, char_u *name, bool use_gettext)
/// Check whether variable is read-only (DI_FLAGS_RO, DI_FLAGS_RO_SBX)
///
/// Also gives an error message.
///
/// @param[in] flags di_flags attribute value.
/// @param[in] name Variable name, for use in error message.
/// @param[in] name_len Variable name length.
///
/// @return True if variable is read-only: either always or in sandbox when
/// sandbox is enabled, false otherwise.
static bool var_check_ro(const int flags, const char *const name,
const size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{
if (flags & DI_FLAGS_RO) {
EMSG2(_(e_readonlyvar), use_gettext ? (char_u *)_(name) : name);
emsgf(_(e_readonlyvar), (int)name_len, name);
return true;
}
if ((flags & DI_FLAGS_RO_SBX) && sandbox) {
EMSG2(_(e_readonlysbx), use_gettext ? (char_u *)_(name) : name);
emsgf(_("E794: Cannot set variable in the sandbox: \"%.*s\""),
(int)name_len, name);
return true;
}
return false;
}
// Return true if di_flags "flags" indicates variable "name" is fixed.
// Also give an error message.
static bool var_check_fixed(int flags, char_u *name, bool use_gettext)
/// Check whether variable is fixed (DI_FLAGS_FIX)
///
/// Also gives an error message.
///
/// @param[in] flags di_flags attribute value.
/// @param[in] name Variable name, for use in error message.
/// @param[in] name_len Variable name length.
///
/// @return True if variable is fixed, false otherwise.
static bool var_check_fixed(const int flags, const char *const name,
const size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{
if (flags & DI_FLAGS_FIX) {
EMSG2(_("E795: Cannot delete variable %s"),
use_gettext ? (char_u *)_(name) : name);
emsgf(_("E795: Cannot delete variable %.*s"), (int)name_len, name);
return true;
}
return false;
@@ -20703,28 +20712,42 @@ static int valid_varname(char_u *varname)
return TRUE;
}
// Return true if typeval "tv" is set to be locked (immutable).
// Also give an error message, using "name" or _("name") when use_gettext is
// true.
static bool tv_check_lock(int lock, char_u *name, bool use_gettext)
/// Check whether typval is locked
///
/// Also gives an error message.
///
/// @param[in] lock Lock status.
/// @param[in] name Value name, for use in error message.
/// @param[in] name_len Value name length.
///
/// @return True if value is locked.
static bool tv_check_lock(const VarLockStatus lock,
const char *const name,
const size_t name_len)
FUNC_ATTR_WARN_UNUSED_RESULT
{
if (lock & VAR_LOCKED) {
EMSG2(_("E741: Value is locked: %s"),
name == NULL
? (char_u *)_("Unknown")
: use_gettext ? (char_u *)_(name)
: name);
return true;
const char *error_message = NULL;
switch (lock) {
case VAR_UNLOCKED: {
return false;
}
case VAR_LOCKED: {
error_message = N_("E741: Value is locked: %.*s");
break;
}
case VAR_FIXED: {
error_message = N_("E742: Cannot change value of %.*s");
break;
}
}
if (lock & VAR_FIXED) {
EMSG2(_("E742: Cannot change value of %s"),
name == NULL
? (char_u *)_("Unknown")
: use_gettext ? (char_u *)_(name)
: name);
return true;
}
return false;
assert(error_message != NULL);
const char *const unknown_name = _("Unknown");
emsgf(_(error_message), (name != NULL ? name_len : strlen(unknown_name)),
(name != NULL ? name : unknown_name));
return true;
}
/*
@@ -21523,11 +21546,13 @@ void ex_function(exarg_T *eap)
goto erret;
}
if (fudi.fd_di == NULL) {
if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg, false)) {
if (tv_check_lock(fudi.fd_dict->dv_lock, (const char *)eap->arg,
STRLEN(eap->arg))) {
// Can't add a function to a locked dictionary
goto erret;
}
} 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, (const char *)eap->arg,
STRLEN(eap->arg))) {
// Can't change an existing function if it is locked
goto erret;
}