mirror of
https://github.com/neovim/neovim.git
synced 2025-09-20 02:08:17 +00:00
Allow lambdas to be used with jobs, timers and dictwatchers.
This commit is contained in:
Michael Ennen
199
src/nvim/eval.c
199
src/nvim/eval.c
@@ -620,9 +620,8 @@ void eval_clear(void)
|
||||
// unreferenced lists and dicts
|
||||
(void)garbage_collect(false);
|
||||
|
||||
/* functions */
|
||||
// functions
|
||||
free_all_functions();
|
||||
hash_clear(&func_hashtab);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -5859,6 +5858,7 @@ bool garbage_collect(bool testing)
|
||||
// referenced through previous_funccal. This must be first, because if
|
||||
// the item is referenced elsewhere the funccal must not be freed.
|
||||
for (funccall_T *fc = previous_funccal; fc != NULL; fc = fc->caller) {
|
||||
fc->fc_copyID = copyID + 1;
|
||||
ABORTING(set_ref_in_ht)(&fc->l_vars.dv_hashtab, copyID + 1, NULL);
|
||||
ABORTING(set_ref_in_ht)(&fc->l_avars.dv_hashtab, copyID + 1, NULL);
|
||||
}
|
||||
@@ -5934,6 +5934,7 @@ bool garbage_collect(bool testing)
|
||||
|
||||
// function-local variables
|
||||
for (funccall_T *fc = current_funccal; fc != NULL; fc = fc->caller) {
|
||||
fc->fc_copyID = copyID;
|
||||
ABORTING(set_ref_in_ht)(&fc->l_vars.dv_hashtab, copyID, NULL);
|
||||
ABORTING(set_ref_in_ht)(&fc->l_avars.dv_hashtab, copyID, NULL);
|
||||
}
|
||||
@@ -5961,8 +5962,8 @@ bool garbage_collect(bool testing)
|
||||
|
||||
// function call arguments, if v:testing is set.
|
||||
for (int i = 0; i < funcargs.ga_len; i++) {
|
||||
ABORTING(set_ref_in_item)(((typval_T **)funcargs.ga_data)[i],
|
||||
copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_item)(((typval_T **)funcargs.ga_data)[i],
|
||||
copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
// v: vars
|
||||
@@ -6248,7 +6249,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack,
|
||||
|
||||
// A partial does not have a copyID, because it cannot contain itself.
|
||||
if (pt != NULL) {
|
||||
abort = abort || set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
|
||||
abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
|
||||
if (pt->pt_dict != NULL) {
|
||||
typval_T dtv;
|
||||
|
||||
@@ -6265,7 +6266,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack,
|
||||
break;
|
||||
}
|
||||
case VAR_FUNC:
|
||||
abort = abort || set_ref_in_func(tv->vval.v_string, NULL, copyID);
|
||||
abort = set_ref_in_func(tv->vval.v_string, NULL, copyID);
|
||||
break;
|
||||
case VAR_UNKNOWN:
|
||||
case VAR_SPECIAL:
|
||||
@@ -6287,48 +6288,19 @@ bool set_ref_in_functions(int copyID)
|
||||
ufunc_T *fp;
|
||||
|
||||
todo = (int)func_hashtab.ht_used;
|
||||
for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) {
|
||||
for (hi = func_hashtab.ht_array; todo > 0 && !got_int; hi++) {
|
||||
if (!HASHITEM_EMPTY(hi)) {
|
||||
todo--;
|
||||
fp = HI2UF(hi);
|
||||
if (!func_name_refcount(fp->uf_name)) {
|
||||
abort = abort || set_ref_in_func(NULL, fp, copyID);
|
||||
abort = abort || set_ref_in_func(NULL, fp, copyID);
|
||||
}
|
||||
}
|
||||
}
|
||||
return abort;
|
||||
}
|
||||
|
||||
/// Mark all lists and dicts referenced through function "name" with "copyID".
|
||||
/// "list_stack" is used to add lists to be marked. Can be NULL.
|
||||
/// "ht_stack" is used to add hashtabs to be marked. Can be NULL.
|
||||
///
|
||||
/// @return true if setting references failed somehow.
|
||||
bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
|
||||
{
|
||||
ufunc_T *fp = fp_in;
|
||||
funccall_T *fc;
|
||||
int error;
|
||||
char_u fname_buf[FLEN_FIXED + 1];
|
||||
char_u *tofree = NULL;
|
||||
char_u *fname;
|
||||
bool abort = false;
|
||||
if (name == NULL && fp_in == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (fp_in == NULL) {
|
||||
fname = fname_trans_sid(name, fname_buf, &tofree, &error);
|
||||
fp = find_func(fname);
|
||||
}
|
||||
if (fp != NULL) {
|
||||
for (fc = fp->uf_scoped; fc != NULL; fc = fc->func->uf_scoped) {
|
||||
abort = abort || set_ref_in_funccal(fc, copyID);
|
||||
}
|
||||
}
|
||||
xfree(tofree);
|
||||
return abort;
|
||||
}
|
||||
|
||||
/// Mark all lists and dicts referenced in given mark
|
||||
///
|
||||
@@ -6378,7 +6350,7 @@ static inline bool set_ref_dict(dict_T *dict, int copyID)
|
||||
|
||||
static bool set_ref_in_funccal(funccall_T *fc, int copyID)
|
||||
{
|
||||
int abort = false;
|
||||
bool abort = false;
|
||||
|
||||
if (fc->fc_copyID != copyID) {
|
||||
fc->fc_copyID = copyID;
|
||||
@@ -6936,7 +6908,7 @@ failret:
|
||||
|
||||
/// Get function arguments.
|
||||
static int get_function_args(char_u **argp, char_u endchar, garray_T *newargs,
|
||||
int *varargs, int skip)
|
||||
int *varargs, bool skip)
|
||||
{
|
||||
bool mustend = false;
|
||||
char_u *arg = *argp;
|
||||
@@ -6979,6 +6951,7 @@ static int get_function_args(char_u **argp, char_u endchar, garray_T *newargs,
|
||||
*p = NUL;
|
||||
arg = vim_strsave(arg);
|
||||
if (arg == NULL) {
|
||||
*p = c;
|
||||
goto err_ret;
|
||||
}
|
||||
|
||||
@@ -7025,10 +6998,11 @@ err_ret:
|
||||
}
|
||||
|
||||
/// Register function "fp" as using "current_funccal" as its scope.
|
||||
static int register_closure(ufunc_T *fp) {
|
||||
static void register_closure(ufunc_T *fp)
|
||||
{
|
||||
if (fp->uf_scoped == current_funccal) {
|
||||
// no change
|
||||
return OK;
|
||||
return;
|
||||
}
|
||||
funccal_unref(fp->uf_scoped, fp, false);
|
||||
fp->uf_scoped = current_funccal;
|
||||
@@ -7036,16 +7010,14 @@ static int register_closure(ufunc_T *fp) {
|
||||
ga_grow(¤t_funccal->fc_funcs, 1);
|
||||
((ufunc_T **)current_funccal->fc_funcs.ga_data)
|
||||
[current_funccal->fc_funcs.ga_len++] = fp;
|
||||
return OK;
|
||||
}
|
||||
|
||||
/// Parse a lambda expression and get a Funcref from "*arg".
|
||||
///
|
||||
/// @return OK or FAIL. Returns NOTDONE for dict or {expr}.
|
||||
static int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate)
|
||||
static int get_lambda_tv(char_u **arg, typval_T *rettv, bool evaluate)
|
||||
{
|
||||
garray_T newargs;
|
||||
garray_T newlines;
|
||||
garray_T newargs = GA_EMPTY_INIT_VALUE;
|
||||
garray_T *pnewargs;
|
||||
ufunc_T *fp = NULL;
|
||||
int varargs;
|
||||
@@ -7056,10 +7028,6 @@ static int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate)
|
||||
int *old_eval_lavars = eval_lavars_used;
|
||||
int eval_lavars = false;
|
||||
|
||||
// TODO(mike): What lengths should be used here?
|
||||
ga_init(&newargs, (int)sizeof(char_u *), 80);
|
||||
ga_init(&newlines, (int)sizeof(char_u *), 80);
|
||||
|
||||
// First, check if this is a lambda expression. "->" must exists.
|
||||
ret = get_function_args(&start, '-', NULL, NULL, true);
|
||||
if (ret == FAIL || *start != '>') {
|
||||
@@ -7102,14 +7070,13 @@ static int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate)
|
||||
char_u *p;
|
||||
char_u name[20];
|
||||
partial_T *pt;
|
||||
garray_T newlines;
|
||||
|
||||
snprintf((char *)name, sizeof(name), "<lambda>%d", lambda_no++);
|
||||
lambda_no++;
|
||||
snprintf((char *)name, sizeof(name), "<lambda>%d", lambda_no);
|
||||
|
||||
fp = (ufunc_T *)xcalloc(1, (unsigned)(sizeof(ufunc_T) + STRLEN(name)));
|
||||
if (fp == NULL) {
|
||||
goto errret;
|
||||
}
|
||||
pt = (partial_T *)xcalloc(1, (unsigned)(sizeof(partial_T)));
|
||||
fp = (ufunc_T *)xcalloc(1, sizeof(ufunc_T) + STRLEN(name));
|
||||
pt = (partial_T *)xcalloc(1, sizeof(partial_T));
|
||||
if (pt == NULL) {
|
||||
xfree(fp);
|
||||
goto errret;
|
||||
@@ -7121,13 +7088,9 @@ static int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate)
|
||||
// Add "return " before the expression.
|
||||
len = 7 + e - s + 1;
|
||||
p = (char_u *)xmalloc(len);
|
||||
if (p == NULL) {
|
||||
goto errret;
|
||||
}
|
||||
((char_u **)(newlines.ga_data))[newlines.ga_len++] = p;
|
||||
STRCPY(p, "return ");
|
||||
STRNCPY(p + 7, s, e - s);
|
||||
p[7 + e - s] = NUL;
|
||||
STRLCPY(p + 7, s, e - s + 1);
|
||||
|
||||
fp->uf_refcount = 1;
|
||||
STRCPY(fp->uf_name, name);
|
||||
@@ -7158,12 +7121,12 @@ static int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate)
|
||||
rettv->vval.v_partial = pt;
|
||||
rettv->v_type = VAR_PARTIAL;
|
||||
}
|
||||
|
||||
eval_lavars_used = old_eval_lavars;
|
||||
return OK;
|
||||
|
||||
errret:
|
||||
ga_clear_strings(&newargs);
|
||||
ga_clear_strings(&newlines);
|
||||
xfree(fp);
|
||||
eval_lavars_used = old_eval_lavars;
|
||||
return FAIL;
|
||||
@@ -7291,9 +7254,6 @@ char_u *get_expr_name(expand_T *xp, int idx)
|
||||
return get_user_var_name(xp, ++intidx);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/// Find internal function in hash functions
|
||||
///
|
||||
/// @param[in] name Name of the function.
|
||||
@@ -7401,7 +7361,7 @@ get_func_tv (
|
||||
ret = FAIL;
|
||||
|
||||
if (ret == OK) {
|
||||
int i = 0;
|
||||
int i = 0;
|
||||
|
||||
if (get_vim_var_nr(VV_TESTING)) {
|
||||
// Prepare for calling garbagecollect_for_testing(), need to know
|
||||
@@ -7413,7 +7373,7 @@ get_func_tv (
|
||||
ga_grow(&funcargs, 1);
|
||||
((typval_T **)funcargs.ga_data)[funcargs.ga_len++] = &argvars[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
ret = call_func(name, len, rettv, argcount, argvars, NULL,
|
||||
firstline, lastline, doesrange, evaluate,
|
||||
partial, selfdict);
|
||||
@@ -7490,6 +7450,37 @@ fname_trans_sid(char_u *name, char_u *fname_buf, char_u **tofree, int *error) {
|
||||
return fname;
|
||||
}
|
||||
|
||||
/// Mark all lists and dicts referenced through function "name" with "copyID".
|
||||
/// "list_stack" is used to add lists to be marked. Can be NULL.
|
||||
/// "ht_stack" is used to add hashtabs to be marked. Can be NULL.
|
||||
///
|
||||
/// @return true if setting references failed somehow.
|
||||
bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
|
||||
{
|
||||
ufunc_T *fp = fp_in;
|
||||
funccall_T *fc;
|
||||
int error = ERROR_NONE;
|
||||
char_u fname_buf[FLEN_FIXED + 1];
|
||||
char_u *tofree = NULL;
|
||||
char_u *fname;
|
||||
bool abort = false;
|
||||
if (name == NULL && fp_in == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (fp_in == NULL) {
|
||||
fname = fname_trans_sid(name, fname_buf, &tofree, &error);
|
||||
fp = find_func(fname);
|
||||
}
|
||||
if (fp != NULL) {
|
||||
for (fc = fp->uf_scoped; fc != NULL; fc = fc->func->uf_scoped) {
|
||||
abort = abort || set_ref_in_funccal(fc, copyID);
|
||||
}
|
||||
}
|
||||
xfree(tofree);
|
||||
return abort;
|
||||
}
|
||||
|
||||
/// Call a function with its resolved parameters
|
||||
///
|
||||
/// "argv_func", when not NULL, can be used to fill in arguments only when the
|
||||
@@ -7612,7 +7603,7 @@ call_func(
|
||||
} else {
|
||||
// Call the user function.
|
||||
call_user_func(fp, argcount, argvars, rettv, firstline, lastline,
|
||||
(fp->uf_flags & FC_DICT) ? selfdict : NULL);
|
||||
(fp->uf_flags & FC_DICT) ? selfdict : NULL);
|
||||
error = ERROR_NONE;
|
||||
}
|
||||
}
|
||||
@@ -8927,11 +8918,6 @@ static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
|
||||
return;
|
||||
}
|
||||
|
||||
if (argvars[2].v_type != VAR_FUNC && argvars[2].v_type != VAR_STRING) {
|
||||
EMSG2(e_invarg2, "funcref");
|
||||
return;
|
||||
}
|
||||
|
||||
char *key_pattern = (char *)get_tv_string_chk(argvars + 1);
|
||||
assert(key_pattern);
|
||||
const size_t key_len = STRLEN(argvars[1].vval.v_string);
|
||||
@@ -8943,6 +8929,7 @@ static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
|
||||
|
||||
Callback callback;
|
||||
if (!callback_from_typval(&callback, &argvars[2])) {
|
||||
EMSG2(e_invarg2, "funcref");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -9744,7 +9731,6 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
|
||||
copy_tv(tv, &vimvars[VV_VAL].vv_tv);
|
||||
argv[0] = vimvars[VV_KEY].vv_tv;
|
||||
argv[1] = vimvars[VV_VAL].vv_tv;
|
||||
s = expr->vval.v_string;
|
||||
if (expr->v_type == VAR_FUNC) {
|
||||
s = expr->vval.v_string;
|
||||
if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
|
||||
@@ -10054,22 +10040,22 @@ static void common_function(typval_T *argvars, typval_T *rettv,
|
||||
use_string = true;
|
||||
}
|
||||
|
||||
if (((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref)) {
|
||||
if ((use_string && vim_strchr(s, AUTOLOAD_CHAR) == NULL) || is_funcref) {
|
||||
name = s;
|
||||
trans_name = trans_function_name(&name, false,
|
||||
TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD
|
||||
| TFN_NO_DEREF, NULL, NULL);
|
||||
if (name != NULL) {
|
||||
if (*name != NUL) {
|
||||
s = NULL;
|
||||
}
|
||||
}
|
||||
if (s == NULL || *s == NUL || (use_string && ascii_isdigit(*s))
|
||||
|| (is_funcref && trans_name == NULL)) {
|
||||
EMSG2(_(e_invarg2), s);
|
||||
EMSG2(_(e_invarg2), use_string ? get_tv_string(&argvars[0]) : s);
|
||||
// Don't check an autoload name for existence here.
|
||||
} else if (trans_name != NULL
|
||||
&& (is_funcref ? find_func(trans_name) == NULL
|
||||
: !translated_function_exists(trans_name))) {
|
||||
// Don't check an autoload name for existence here.
|
||||
EMSG2(_("E700: Unknown function: %s"), s);
|
||||
} else {
|
||||
int dict_idx = 0;
|
||||
@@ -17733,7 +17719,8 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
|
||||
}
|
||||
|
||||
// "test_garbagecollect_now()" function
|
||||
static void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv, FunPtr fptr)
|
||||
static void f_test_garbagecollect_now(typval_T *argvars,
|
||||
typval_T *rettv, FunPtr fptr)
|
||||
{
|
||||
// This is dangerous, any Lists and Dicts used internally may be freed
|
||||
// while still in use.
|
||||
@@ -18481,7 +18468,8 @@ static bool write_list(FILE *fd, list_T *list, bool binary)
|
||||
}
|
||||
|
||||
/// Initializes a static list with 10 items.
|
||||
void init_static_list(staticList10_T *sl) {
|
||||
void init_static_list(staticList10_T *sl)
|
||||
{
|
||||
list_T *l = &sl->sl_list;
|
||||
|
||||
memset(sl, 0, sizeof(staticList10_T));
|
||||
@@ -19487,7 +19475,8 @@ static void set_selfdict(typval_T *rettv, dict_T *selfdict)
|
||||
if (rettv->v_type == VAR_PARTIAL && rettv->vval.v_partial->pt_func != NULL) {
|
||||
fp = rettv->vval.v_partial->pt_func;
|
||||
} else {
|
||||
fname = rettv->v_type == VAR_FUNC ? rettv->vval.v_string
|
||||
fname = rettv->v_type == VAR_FUNC || rettv->v_type == VAR_STRING
|
||||
? rettv->vval.v_string
|
||||
: rettv->vval.v_partial->pt_name;
|
||||
// Translate "s:func" to the stored function name.
|
||||
fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
|
||||
@@ -21362,7 +21351,7 @@ void ex_function(exarg_T *eap)
|
||||
emsg_funcname(e_funcexts, name);
|
||||
goto erret;
|
||||
}
|
||||
if (fp->uf_refcount > 1 || fp->uf_calls > 0) {
|
||||
if (fp->uf_calls > 0) {
|
||||
emsg_funcname(N_("E127: Cannot redefine function %s: It is in use"),
|
||||
name);
|
||||
goto erret;
|
||||
@@ -21463,7 +21452,7 @@ void ex_function(exarg_T *eap)
|
||||
xfree(fp);
|
||||
goto erret;
|
||||
}
|
||||
fp->uf_refcount = 1;
|
||||
fp->uf_refcount = 1;
|
||||
}
|
||||
fp->uf_args = newargs;
|
||||
fp->uf_lines = newlines;
|
||||
@@ -21572,11 +21561,11 @@ trans_function_name(
|
||||
fdp->fd_di = lv.ll_di;
|
||||
}
|
||||
if (lv.ll_tv->v_type == VAR_FUNC && lv.ll_tv->vval.v_string != NULL) {
|
||||
name = vim_strsave(partial_name(lv.ll_tv->vval.v_partial));
|
||||
name = vim_strsave(lv.ll_tv->vval.v_string);
|
||||
*pp = end;
|
||||
} else if (lv.ll_tv->v_type == VAR_PARTIAL
|
||||
&& lv.ll_tv->vval.v_partial != NULL) {
|
||||
name = vim_strsave(lv.ll_tv->vval.v_partial->pt_name);
|
||||
name = vim_strsave(partial_name(lv.ll_tv->vval.v_partial));
|
||||
*pp = end;
|
||||
if (partial != NULL) {
|
||||
*partial = lv.ll_tv->vval.v_partial;
|
||||
@@ -22220,7 +22209,7 @@ void ex_delfunction(exarg_T *eap)
|
||||
// A normal function (not a numbered function or lambda) has a
|
||||
// refcount of 1 for the entry in the hashtable. When deleting
|
||||
// it and the refcount is more than one, it should be kept.
|
||||
// A numbered function or lambda snould be kept if the refcount is
|
||||
// A numbered function or lambda should be kept if the refcount is
|
||||
// one or more.
|
||||
if (fp->uf_refcount > (func_name_refcount(fp->uf_name) ? 0 : 1)) {
|
||||
// Function is still referenced somewhere. Don't free it but
|
||||
@@ -22270,7 +22259,6 @@ static void func_free(ufunc_T *fp, bool force)
|
||||
func_remove(fp);
|
||||
}
|
||||
funccal_unref(fp->uf_scoped, fp, force);
|
||||
func_remove(fp);
|
||||
xfree(fp);
|
||||
}
|
||||
|
||||
@@ -22285,27 +22273,19 @@ void func_unref(char_u *name)
|
||||
if (name == NULL || !func_name_refcount(name)) {
|
||||
return;
|
||||
}
|
||||
if (isdigit(*name)) {
|
||||
fp = find_func(name);
|
||||
if (fp == NULL) {
|
||||
|
||||
fp = find_func(name);
|
||||
if (fp == NULL && isdigit(*name)) {
|
||||
#ifdef EXITFREE
|
||||
if (!entered_free_all_mem) {
|
||||
EMSG2(_(e_intern2), "func_unref()");
|
||||
}
|
||||
if (!entered_free_all_mem) {
|
||||
EMSG2(_(e_intern2), "func_unref()");
|
||||
abort();
|
||||
}
|
||||
#else
|
||||
EMSG2(_(e_intern2), "func_unref()");
|
||||
abort();
|
||||
#endif
|
||||
} else {
|
||||
user_func_unref(fp);
|
||||
}
|
||||
} else if (STRNCMP(name, "<lambda>", 8) == 0) {
|
||||
// fail silently, when lambda function isn't found
|
||||
fp = find_func(name);
|
||||
}
|
||||
if (fp == NULL && isdigit(*name)) {
|
||||
EMSG2(_(e_intern2), "func_unref()");
|
||||
}
|
||||
|
||||
if (fp != NULL && --fp->uf_refcount <= 0) {
|
||||
// Only delete it when it's not being used. Otherwise it's done
|
||||
// when "uf_calls" becomes zero.
|
||||
@@ -22357,13 +22337,13 @@ void func_ptr_ref(ufunc_T *fp)
|
||||
/// Call a user function.
|
||||
static void
|
||||
call_user_func(
|
||||
ufunc_T *fp, /* pointer to function */
|
||||
int argcount, /* nr of args */
|
||||
typval_T *argvars, /* arguments */
|
||||
typval_T *rettv, /* return value */
|
||||
linenr_T firstline, /* first line of range */
|
||||
linenr_T lastline, /* last line of range */
|
||||
dict_T *selfdict /* Dictionary for "self" */
|
||||
ufunc_T *fp, // pointer to function
|
||||
int argcount, // nr of args
|
||||
typval_T *argvars, // arguments
|
||||
typval_T *rettv, // return value
|
||||
linenr_T firstline, // first line of range
|
||||
linenr_T lastline, // last line of range
|
||||
dict_T *selfdict // Dictionary for "self"
|
||||
)
|
||||
{
|
||||
char_u *save_sourcing_name;
|
||||
@@ -22770,7 +22750,6 @@ static void funccal_unref(funccall_T *fc, ufunc_T *fp, bool force)
|
||||
}
|
||||
for (i = 0; i < fc->fc_funcs.ga_len; i++) {
|
||||
if (((ufunc_T **)(fc->fc_funcs.ga_data))[i] == fp) {
|
||||
func_ptr_unref(fc->func);
|
||||
((ufunc_T **)(fc->fc_funcs.ga_data))[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user