CheckScriptFailure(lines, 'E1012:')
enddef
+def Test_global_closure()
+ var lines =<< trim END
+ vim9script
+ def ReverseEveryNLines(n: number, line1: number, line2: number)
+ var mods = 'sil keepj keepp lockm '
+ var range = ':' .. line1 .. ',' .. line2
+ def g:Offset(): number
+ var offset = (line('.') - line1 + 1) % n
+ return offset != 0 ? offset : n
+ enddef
+ exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
+ enddef
+
+ new
+ repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
+ ReverseEveryNLines(3, 1, 9)
+ END
+ CheckScriptSuccess(lines)
+ var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
+ assert_equal(expected, getline(1, 9))
+ bwipe!
+enddef
+
def Test_failure_in_called_function()
# this was using the frame index as the return value
var lines =<< trim END
VIM_CLEAR(fp->uf_block_ids);
VIM_CLEAR(fp->uf_va_name);
clear_type_list(&fp->uf_type_list);
+ partial_unref(fp->uf_partial);
+ fp->uf_partial = NULL;
#ifdef FEAT_LUA
if (fp->uf_cb_free != NULL)
/*
* Copy already defined function "lambda" to a new function with name "global".
* This is for when a compiled function defines a global function.
+ * Caller should take care of adding a partial for a closure.
*/
- void
+ ufunc_T *
copy_func(char_u *lambda, char_u *global)
{
ufunc_T *ufunc = find_func_even_dead(lambda, TRUE, NULL);
- ufunc_T *fp;
+ ufunc_T *fp = NULL;
if (ufunc == NULL)
semsg(_(e_lambda_function_not_found_str), lambda);
if (fp != NULL)
{
semsg(_(e_funcexts), global);
- return;
+ return NULL;
}
fp = alloc_clear(offsetof(ufunc_T, uf_name) + STRLEN(global) + 1);
if (fp == NULL)
- return;
+ return NULL;
fp->uf_varargs = ufunc->uf_varargs;
fp->uf_flags = (ufunc->uf_flags & ~FC_VIM9) | FC_COPY;
if (fp->uf_va_name == NULL)
goto failed;
}
+ fp->uf_ret_type = ufunc->uf_ret_type;
fp->uf_refcount = 1;
STRCPY(fp->uf_name, global);
hash_add(&func_hashtab, UF2HIKEY(fp));
}
- return;
+ return fp;
failed:
func_clear_free(fp, TRUE);
+ return NULL;
}
static int funcdepth = 0;
return res;
}
+/*
+ * When a function reference is used, fill a partial with the information
+ * needed, especially when it is used as a closure.
+ */
+ static int
+fill_partial_and_closure(partial_T *pt, ufunc_T *ufunc, ectx_T *ectx)
+{
+ pt->pt_func = ufunc;
+ pt->pt_refcount = 1;
+
+ if (pt->pt_func->uf_flags & FC_CLOSURE)
+ {
+ dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
+ + ectx->ec_dfunc_idx;
+
+ // The closure needs to find arguments and local
+ // variables in the current stack.
+ pt->pt_ectx_stack = &ectx->ec_stack;
+ pt->pt_ectx_frame = ectx->ec_frame_idx;
+
+ // If this function returns and the closure is still
+ // being used, we need to make a copy of the context
+ // (arguments and local variables). Store a reference
+ // to the partial so we can handle that.
+ if (ga_grow(&ectx->ec_funcrefs, 1) == FAIL)
+ {
+ vim_free(pt);
+ return FAIL;
+ }
+ // Extra variable keeps the count of closures created
+ // in the current function call.
+ ++(((typval_T *)ectx->ec_stack.ga_data) + ectx->ec_frame_idx
+ + STACK_FRAME_SIZE + dfunc->df_varcount)->vval.v_number;
+
+ ((partial_T **)ectx->ec_funcrefs.ga_data)
+ [ectx->ec_funcrefs.ga_len] = pt;
+ ++pt->pt_refcount;
+ ++ectx->ec_funcrefs.ga_len;
+ }
+ ++pt->pt_func->uf_refcount;
+ return OK;
+}
+
/*
* Call a "def" function from old Vim script.
* Return OK or FAIL.
ectx.ec_outer_frame = partial->pt_ectx_frame;
}
}
+ else if (ufunc->uf_partial != NULL)
+ {
+ ectx.ec_outer_stack = ufunc->uf_partial->pt_ectx_stack;
+ ectx.ec_outer_frame = ufunc->uf_partial->pt_ectx_frame;
+ }
// dummy frame entries
for (idx = 0; idx < STACK_FRAME_SIZE; ++idx)
// push a function reference to a compiled function
case ISN_FUNCREF:
{
- partial_T *pt = NULL;
- dfunc_T *pt_dfunc;
+ partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
+ dfunc_T *pt_dfunc = ((dfunc_T *)def_functions.ga_data)
+ + iptr->isn_arg.funcref.fr_func;
- pt = ALLOC_CLEAR_ONE(partial_T);
if (pt == NULL)
goto failed;
if (GA_GROW(&ectx.ec_stack, 1) == FAIL)
vim_free(pt);
goto failed;
}
- pt_dfunc = ((dfunc_T *)def_functions.ga_data)
- + iptr->isn_arg.funcref.fr_func;
- pt->pt_func = pt_dfunc->df_ufunc;
- pt->pt_refcount = 1;
-
- if (pt_dfunc->df_ufunc->uf_flags & FC_CLOSURE)
- {
- dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
- + ectx.ec_dfunc_idx;
-
- // The closure needs to find arguments and local
- // variables in the current stack.
- pt->pt_ectx_stack = &ectx.ec_stack;
- pt->pt_ectx_frame = ectx.ec_frame_idx;
-
- // If this function returns and the closure is still
- // being used, we need to make a copy of the context
- // (arguments and local variables). Store a reference
- // to the partial so we can handle that.
- if (ga_grow(&ectx.ec_funcrefs, 1) == FAIL)
- {
- vim_free(pt);
- goto failed;
- }
- // Extra variable keeps the count of closures created
- // in the current function call.
- tv = STACK_TV_VAR(dfunc->df_varcount);
- ++tv->vval.v_number;
-
- ((partial_T **)ectx.ec_funcrefs.ga_data)
- [ectx.ec_funcrefs.ga_len] = pt;
- ++pt->pt_refcount;
- ++ectx.ec_funcrefs.ga_len;
- }
- ++pt_dfunc->df_ufunc->uf_refcount;
+ if (fill_partial_and_closure(pt, pt_dfunc->df_ufunc,
+ &ectx) == FAIL)
+ goto failed;
tv = STACK_TV_BOT(0);
++ectx.ec_stack.ga_len;
case ISN_NEWFUNC:
{
newfunc_T *newfunc = &iptr->isn_arg.newfunc;
+ ufunc_T *new_ufunc;
- copy_func(newfunc->nf_lambda, newfunc->nf_global);
+ new_ufunc = copy_func(
+ newfunc->nf_lambda, newfunc->nf_global);
+ if (new_ufunc != NULL
+ && (new_ufunc->uf_flags & FC_CLOSURE))
+ {
+ partial_T *pt = ALLOC_CLEAR_ONE(partial_T);
+
+ // Need to create a partial to store the context of the
+ // function.
+ if (pt == NULL)
+ goto failed;
+ if (fill_partial_and_closure(pt, new_ufunc,
+ &ectx) == FAIL)
+ goto failed;
+ new_ufunc->uf_partial = pt;
+ --pt->pt_refcount; // not referenced here
+ }
}
break;
// Deal with any remaining closures, they may be in use somewhere.
if (ectx.ec_funcrefs.ga_len > 0)
+ {
handle_closure_in_use(&ectx, FALSE);
+ ga_clear(&ectx.ec_funcrefs); // TODO: should not be needed?
+ }
estack_pop();
current_sctx = save_current_sctx;
projects / thirdparty / vim.git / commitdiff
