void
channel_set_options(channel_T *channel, jobopt_T *opt)
{
- int part;
- char_u **cbp;
+ int part;
+ char_u **cbp;
+ partial_T **pp;
if (opt->jo_set & JO_MODE)
for (part = PART_SOCK; part <= PART_IN; ++part)
if (opt->jo_set & JO_CALLBACK)
{
cbp = &channel->ch_callback;
+ pp = &channel->ch_partial;
vim_free(*cbp);
+ partial_unref(*pp);
if (opt->jo_callback != NULL && *opt->jo_callback != NUL)
*cbp = vim_strsave(opt->jo_callback);
else
*cbp = NULL;
+ *pp = opt->jo_partial;
+ if (*pp != NULL)
+ ++(*pp)->pt_refcount;
}
if (opt->jo_set & JO_OUT_CALLBACK)
{
cbp = &channel->ch_part[PART_OUT].ch_callback;
+ pp = &channel->ch_part[PART_OUT].ch_partial;
vim_free(*cbp);
+ partial_unref(*pp);
if (opt->jo_out_cb != NULL && *opt->jo_out_cb != NUL)
*cbp = vim_strsave(opt->jo_out_cb);
else
*cbp = NULL;
+ *pp = opt->jo_out_partial;
+ if (*pp != NULL)
+ ++(*pp)->pt_refcount;
}
if (opt->jo_set & JO_ERR_CALLBACK)
{
cbp = &channel->ch_part[PART_ERR].ch_callback;
+ pp = &channel->ch_part[PART_ERR].ch_partial;
vim_free(*cbp);
+ partial_unref(*pp);
if (opt->jo_err_cb != NULL && *opt->jo_err_cb != NUL)
*cbp = vim_strsave(opt->jo_err_cb);
else
*cbp = NULL;
+ *pp = opt->jo_err_partial;
+ if (*pp != NULL)
+ ++(*pp)->pt_refcount;
}
if (opt->jo_set & JO_CLOSE_CALLBACK)
{
cbp = &channel->ch_close_cb;
+ pp = &channel->ch_close_partial;
vim_free(*cbp);
+ partial_unref(*pp);
if (opt->jo_close_cb != NULL && *opt->jo_close_cb != NUL)
*cbp = vim_strsave(opt->jo_close_cb);
else
*cbp = NULL;
+ *pp = opt->jo_err_partial;
+ if (*pp != NULL)
+ ++(*pp)->pt_refcount;
}
if ((opt->jo_set & JO_OUT_IO) && opt->jo_io[PART_OUT] == JIO_BUFFER)
*/
void
channel_set_req_callback(
- channel_T *channel,
- int part,
- char_u *callback,
- int id)
+ channel_T *channel,
+ int part,
+ char_u *callback,
+ partial_T *partial,
+ int id)
{
cbq_T *head = &channel->ch_part[part].ch_cb_head;
cbq_T *item = (cbq_T *)alloc((int)sizeof(cbq_T));
if (item != NULL)
{
item->cq_callback = vim_strsave(callback);
+ item->cq_partial = partial;
+ if (partial != NULL)
+ ++partial->pt_refcount;
item->cq_seq_nr = id;
item->cq_prev = head->cq_prev;
head->cq_prev = item;
* Invoke the "callback" on channel "channel".
*/
static void
-invoke_callback(channel_T *channel, char_u *callback, typval_T *argv)
+invoke_callback(channel_T *channel, char_u *callback, partial_T *partial,
+ typval_T *argv)
{
typval_T rettv;
int dummy;
argv[0].vval.v_channel = channel;
call_func(callback, (int)STRLEN(callback),
- &rettv, 2, argv, 0L, 0L, &dummy, TRUE, NULL);
+ &rettv, 2, argv, 0L, 0L, &dummy, TRUE, partial, NULL);
clear_tv(&rettv);
/* If an echo command was used the cursor needs to be put back where
++emsg_skip;
if (!is_call)
tv = eval_expr(arg, NULL);
- else if (func_call(arg, &argv[2], NULL, &res_tv) == OK)
+ else if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
tv = &res_tv;
else
tv = NULL;
/* Remove the item from the list first, if the callback
* invokes ch_close() the list will be cleared. */
remove_cb_node(cbhead, item);
- invoke_callback(channel, item->cq_callback, argv);
+ invoke_callback(channel, item->cq_callback, item->cq_partial, argv);
vim_free(item->cq_callback);
+ partial_unref(item->cq_partial);
vim_free(item);
}
cbq_T *cbhead = &channel->ch_part[part].ch_cb_head;
cbq_T *cbitem;
char_u *callback = NULL;
+ partial_T *partial = NULL;
buf_T *buffer = NULL;
if (channel->ch_nb_close_cb != NULL)
if (cbitem->cq_seq_nr == 0)
break;
if (cbitem != NULL)
+ {
callback = cbitem->cq_callback;
+ partial = cbitem->cq_partial;
+ }
else if (channel->ch_part[part].ch_callback != NULL)
+ {
callback = channel->ch_part[part].ch_callback;
+ partial = channel->ch_part[part].ch_partial;
+ }
else
+ {
callback = channel->ch_callback;
+ partial = channel->ch_partial;
+ }
buffer = channel->ch_part[part].ch_buffer;
if (buffer != NULL && !buf_valid(buffer))
/* invoke the channel callback */
ch_logs(channel, "Invoking channel callback %s",
(char *)callback);
- invoke_callback(channel, callback, argv);
+ invoke_callback(channel, callback, partial, argv);
}
}
}
argv[0].vval.v_channel = channel;
++channel->ch_refcount;
call_func(channel->ch_close_cb, (int)STRLEN(channel->ch_close_cb),
- &rettv, 1, argv, 0L, 0L, &dummy, TRUE, NULL);
+ &rettv, 1, argv, 0L, 0L, &dummy, TRUE,
+ channel->ch_close_partial, NULL);
clear_tv(&rettv);
--channel->ch_refcount;
/* the callback is only called once */
vim_free(channel->ch_close_cb);
channel->ch_close_cb = NULL;
+ partial_unref(channel->ch_close_partial);
+ channel->ch_close_partial = NULL;
}
channel->ch_nb_close_cb = NULL;
remove_cb_node(cb_head, node);
vim_free(node->cq_callback);
+ partial_unref(node->cq_partial);
vim_free(node);
}
vim_free(channel->ch_part[part].ch_callback);
channel->ch_part[part].ch_callback = NULL;
+ partial_unref(channel->ch_part[part].ch_partial);
+ channel->ch_part[part].ch_partial = NULL;
}
/*
channel_clear_one(channel, PART_ERR);
vim_free(channel->ch_callback);
channel->ch_callback = NULL;
+ partial_unref(channel->ch_partial);
+ channel->ch_partial = NULL;
vim_free(channel->ch_close_cb);
channel->ch_close_cb = NULL;
+ partial_unref(channel->ch_close_partial);
+ channel->ch_close_partial = NULL;
}
#if defined(EXITFREE) || defined(PROTO)
EMSG2(_("E917: Cannot use a callback with %s()"), fun);
return NULL;
}
- channel_set_req_callback(channel, part_send, opt->jo_callback, id);
+ channel_set_req_callback(channel, part_send,
+ opt->jo_callback, opt->jo_partial, id);
}
if (channel_send(channel, part_send, text, fun) == OK
* Return NULL for an invalid argument.
*/
static char_u *
-get_callback(typval_T *arg)
+get_callback(typval_T *arg, partial_T **pp)
{
+ if (arg->v_type == VAR_PARTIAL && arg->vval.v_partial != NULL)
+ {
+ *pp = arg->vval.v_partial;
+ return (*pp)->pt_name;
+ }
+ *pp = NULL;
if (arg->v_type == VAR_FUNC || arg->v_type == VAR_STRING)
return arg->vval.v_string;
if (arg->v_type == VAR_NUMBER && arg->vval.v_number == 0)
return (char_u *)"";
- EMSG(_("E999: Invalid callback argument"));
+ EMSG(_("E921: Invalid callback argument"));
return NULL;
}
if (!(supported & JO_CALLBACK))
break;
opt->jo_set |= JO_CALLBACK;
- opt->jo_callback = get_callback(item);
+ opt->jo_callback = get_callback(item, &opt->jo_partial);
if (opt->jo_callback == NULL)
{
EMSG2(_(e_invarg2), "callback");
if (!(supported & JO_OUT_CALLBACK))
break;
opt->jo_set |= JO_OUT_CALLBACK;
- opt->jo_out_cb = get_callback(item);
+ opt->jo_out_cb = get_callback(item, &opt->jo_out_partial);
if (opt->jo_out_cb == NULL)
{
EMSG2(_(e_invarg2), "out-cb");
if (!(supported & JO_ERR_CALLBACK))
break;
opt->jo_set |= JO_ERR_CALLBACK;
- opt->jo_err_cb = get_callback(item);
+ opt->jo_err_cb = get_callback(item, &opt->jo_err_partial);
if (opt->jo_err_cb == NULL)
{
EMSG2(_(e_invarg2), "err-cb");
if (!(supported & JO_CLOSE_CALLBACK))
break;
opt->jo_set |= JO_CLOSE_CALLBACK;
- opt->jo_close_cb = get_callback(item);
+ opt->jo_close_cb = get_callback(item, &opt->jo_close_partial);
if (opt->jo_close_cb == NULL)
{
EMSG2(_(e_invarg2), "close-cb");
if (!(supported & JO_EXIT_CB))
break;
opt->jo_set |= JO_EXIT_CB;
- opt->jo_exit_cb = get_tv_string_buf_chk(item, opt->jo_ecb_buf);
+ if (item->v_type == VAR_PARTIAL && item->vval.v_partial != NULL)
+ {
+ opt->jo_exit_partial = item->vval.v_partial;
+ opt->jo_exit_cb = item->vval.v_partial->pt_name;
+ }
+ else
+ opt->jo_exit_cb = get_tv_string_buf_chk(
+ item, opt->jo_ecb_buf);
if (opt->jo_exit_cb == NULL)
{
EMSG2(_(e_invarg2), "exit-cb");
vim_free(job->jv_stoponexit);
vim_free(job->jv_exit_cb);
+ partial_unref(job->jv_exit_partial);
vim_free(job);
}
if (opt->jo_set & JO_EXIT_CB)
{
vim_free(job->jv_exit_cb);
+ partial_unref(job->jv_exit_partial);
if (opt->jo_exit_cb == NULL || *opt->jo_exit_cb == NUL)
+ {
job->jv_exit_cb = NULL;
+ job->jv_exit_partial = NULL;
+ }
else
+ {
job->jv_exit_cb = vim_strsave(opt->jo_exit_cb);
+ job->jv_exit_partial = opt->jo_exit_partial;
+ if (job->jv_exit_partial != NULL)
+ ++job->jv_exit_partial->pt_refcount;
+ }
}
}
argv[1].v_type = VAR_NUMBER;
argv[1].vval.v_number = job->jv_exitval;
call_func(job->jv_exit_cb, (int)STRLEN(job->jv_exit_cb),
- &rettv, 2, argv, 0L, 0L, &dummy, TRUE, NULL);
+ &rettv, 2, argv, 0L, 0L, &dummy, TRUE,
+ job->jv_exit_partial, NULL);
clear_tv(&rettv);
--job->jv_refcount;
}
static char_u *string_quote(char_u *str, int function);
static int get_env_tv(char_u **arg, typval_T *rettv, int evaluate);
static int find_internal_func(char_u *name);
-static char_u *deref_func_name(char_u *name, int *lenp, int no_autoload);
-static int get_func_tv(char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict);
+static char_u *deref_func_name(char_u *name, int *lenp, partial_T **partial, int no_autoload);
+static int get_func_tv(char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, partial_T *partial, dict_T *selfdict);
static void emsg_funcname(char *ermsg, char_u *name);
static int non_zero_arg(typval_T *argvars);
rettv->v_type = VAR_UNKNOWN; /* clear_tv() uses this */
ret = call_func(func, (int)STRLEN(func), rettv, argc, argvars,
curwin->w_cursor.lnum, curwin->w_cursor.lnum,
- &doesrange, TRUE, NULL);
+ &doesrange, TRUE, NULL, NULL);
if (safe)
{
--sandbox;
case VAR_UNKNOWN:
case VAR_DICT:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_SPECIAL:
case VAR_JOB:
case VAR_CHANNEL:
int doesrange;
int failed = FALSE;
funcdict_T fudi;
+ partial_T *partial;
if (eap->skip)
{
/* If it is the name of a variable of type VAR_FUNC use its contents. */
len = (int)STRLEN(tofree);
- name = deref_func_name(tofree, &len, FALSE);
+ name = deref_func_name(tofree, &len, &partial, FALSE);
/* Skip white space to allow ":call func ()". Not good, but required for
* backward compatibility. */
arg = startarg;
if (get_func_tv(name, (int)STRLEN(name), &rettv, &arg,
eap->line1, eap->line2, &doesrange,
- !eap->skip, fudi.fd_dict) == FAIL)
+ !eap->skip, partial, fudi.fd_dict) == FAIL)
{
failed = TRUE;
break;
case VAR_NUMBER:
case VAR_STRING:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_FLOAT:
case VAR_SPECIAL:
case VAR_JOB:
}
}
- else if (rettv->v_type == VAR_FUNC || var2.v_type == VAR_FUNC)
+ else if (rettv->v_type == VAR_FUNC || var2.v_type == VAR_FUNC
+ || rettv->v_type == VAR_PARTIAL || var2.v_type == VAR_PARTIAL)
{
if (rettv->v_type != var2.v_type
|| (type != TYPE_EQUAL && type != TYPE_NEQUAL))
clear_tv(&var2);
return FAIL;
}
+ else if (rettv->v_type == VAR_PARTIAL)
+ {
+ /* Partials are only equal when identical. */
+ n1 = rettv->vval.v_partial != NULL
+ && rettv->vval.v_partial == var2.vval.v_partial;
+ }
else
{
/* Compare two Funcrefs for being equal or unequal. */
else
n1 = STRCMP(rettv->vval.v_string,
var2.vval.v_string) == 0;
- if (type == TYPE_NEQUAL)
- n1 = !n1;
}
+ if (type == TYPE_NEQUAL)
+ n1 = !n1;
}
#ifdef FEAT_FLOAT
{
if (**arg == '(') /* recursive! */
{
+ partial_T *partial;
+
/* If "s" is the name of a variable of type VAR_FUNC
* use its contents. */
- s = deref_func_name(s, &len, !evaluate);
+ s = deref_func_name(s, &len, &partial, !evaluate);
/* Invoke the function. */
ret = get_func_tv(s, len, rettv, arg,
curwin->w_cursor.lnum, curwin->w_cursor.lnum,
- &len, evaluate, NULL);
+ &len, evaluate, partial, NULL);
/* If evaluate is FALSE rettv->v_type was not set in
* get_func_tv, but it's needed in handle_subscript() to parse
switch (rettv->v_type)
{
case VAR_FUNC:
+ case VAR_PARTIAL:
if (verbose)
EMSG(_("E695: Cannot index a Funcref"));
return FAIL;
{
case VAR_UNKNOWN:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_FLOAT:
case VAR_SPECIAL:
case VAR_JOB:
&& tv2->vval.v_string != NULL
&& STRCMP(tv1->vval.v_string, tv2->vval.v_string) == 0);
+ case VAR_PARTIAL:
+ return tv1->vval.v_partial != NULL
+ && tv1->vval.v_partial == tv2->vval.v_partial;
+
case VAR_NUMBER:
return tv1->vval.v_number == tv2->vval.v_number;
r = tv->vval.v_string;
break;
+ case VAR_PARTIAL:
+ *tofree = NULL;
+ /* TODO: arguments */
+ r = tv->vval.v_partial == NULL ? NULL : tv->vval.v_partial->pt_name;
+ break;
+
case VAR_LIST:
if (tv->vval.v_list == NULL)
{
case VAR_FUNC:
*tofree = string_quote(tv->vval.v_string, TRUE);
return *tofree;
+ case VAR_PARTIAL:
+ *tofree = string_quote(tv->vval.v_partial == NULL ? NULL
+ : tv->vval.v_partial->pt_name, TRUE);
+ return *tofree;
case VAR_STRING:
*tofree = string_quote(tv->vval.v_string, FALSE);
return *tofree;
{"foldtext", 0, 0, f_foldtext},
{"foldtextresult", 1, 1, f_foldtextresult},
{"foreground", 0, 0, f_foreground},
- {"function", 1, 1, f_function},
+ {"function", 1, 3, f_function},
{"garbagecollect", 0, 1, f_garbagecollect},
{"get", 2, 3, f_get},
{"getbufline", 2, 3, f_getbufline},
/*
* Check if "name" is a variable of type VAR_FUNC. If so, return the function
* name it contains, otherwise return "name".
+ * If "name" is of type VAR_PARTIAL also return "partial"
*/
static char_u *
-deref_func_name(char_u *name, int *lenp, int no_autoload)
+deref_func_name(char_u *name, int *lenp, partial_T **partial, int no_autoload)
{
dictitem_T *v;
int cc;
+ *partial = NULL;
+
cc = name[*lenp];
name[*lenp] = NUL;
v = find_var(name, NULL, no_autoload);
return v->di_tv.vval.v_string;
}
+ if (v != NULL && v->di_tv.v_type == VAR_PARTIAL)
+ {
+ *partial = v->di_tv.vval.v_partial;
+ if (*partial == NULL)
+ {
+ *lenp = 0;
+ return (char_u *)""; /* just in case */
+ }
+ *lenp = (int)STRLEN((*partial)->pt_name);
+ return (*partial)->pt_name;
+ }
+
return name;
}
linenr_T lastline, /* last line of range */
int *doesrange, /* return: function handled range */
int evaluate,
+ partial_T *partial, /* for extra arguments */
dict_T *selfdict) /* Dictionary for "self" */
{
char_u *argp;
* Get the arguments.
*/
argp = *arg;
- while (argcount < MAX_FUNC_ARGS)
+ while (argcount < MAX_FUNC_ARGS - (partial == NULL ? 0 : partial->pt_argc))
{
argp = skipwhite(argp + 1); /* skip the '(' or ',' */
if (*argp == ')' || *argp == ',' || *argp == NUL)
if (ret == OK)
ret = call_func(name, len, rettv, argcount, argvars,
- firstline, lastline, doesrange, evaluate, selfdict);
+ firstline, lastline, doesrange, evaluate, partial, selfdict);
else if (!aborting())
{
if (argcount == MAX_FUNC_ARGS)
char_u *funcname, /* name of the function */
int len, /* length of "name" */
typval_T *rettv, /* return value goes here */
- int argcount, /* number of "argvars" */
- typval_T *argvars, /* vars for arguments, must have "argcount"
+ int argcount_in, /* number of "argvars" */
+ typval_T *argvars_in, /* vars for arguments, must have "argcount"
PLUS ONE elements! */
linenr_T firstline, /* first line of range */
linenr_T lastline, /* last line of range */
int *doesrange, /* return: function handled range */
int evaluate,
- dict_T *selfdict) /* Dictionary for "self" */
+ partial_T *partial, /* optional, can be NULL */
+ dict_T *selfdict_in) /* Dictionary for "self" */
{
int ret = FAIL;
#define ERROR_UNKNOWN 0
#define ERROR_DICT 4
#define ERROR_NONE 5
#define ERROR_OTHER 6
+#define ERROR_BOTH 7
int error = ERROR_NONE;
int i;
int llen;
char_u fname_buf[FLEN_FIXED + 1];
char_u *fname;
char_u *name;
+ int argcount = argcount_in;
+ typval_T *argvars = argvars_in;
+ dict_T *selfdict = selfdict_in;
+ typval_T argv[MAX_FUNC_ARGS + 1]; /* used when "partial" is not NULL */
+ int argv_clear = 0;
/* Make a copy of the name, if it comes from a funcref variable it could
* be changed or deleted in the called function. */
*doesrange = FALSE;
+ if (partial != NULL)
+ {
+ if (partial->pt_dict != NULL)
+ {
+ if (selfdict_in != NULL)
+ error = ERROR_BOTH;
+ selfdict = partial->pt_dict;
+ }
+ if (error == ERROR_NONE && partial->pt_argc > 0)
+ {
+ int i;
+
+ for (argv_clear = 0; argv_clear < partial->pt_argc; ++argv_clear)
+ copy_tv(&partial->pt_argv[argv_clear], &argv[argv_clear]);
+ for (i = 0; i < argcount_in; ++i)
+ argv[i + argv_clear] = argvars_in[i];
+ argvars = argv;
+ argcount = partial->pt_argc + argcount_in;
+ }
+ }
+
/* execute the function if no errors detected and executing */
if (evaluate && error == ERROR_NONE)
emsg_funcname(N_("E725: Calling dict function without Dictionary: %s"),
name);
break;
+ case ERROR_BOTH:
+ emsg_funcname(N_("E924: can't have both a \"self\" dict and a partial: %s"),
+ name);
+ break;
}
}
+ while (argv_clear > 0)
+ clear_tv(&argv[--argv_clear]);
if (fname != name && fname != fname_buf)
vim_free(fname);
vim_free(name);
func_call(
char_u *name,
typval_T *args,
+ partial_T *partial,
dict_T *selfdict,
typval_T *rettv)
{
for (item = args->vval.v_list->lv_first; item != NULL;
item = item->li_next)
{
- if (argc == MAX_FUNC_ARGS)
+ if (argc == MAX_FUNC_ARGS - (partial == NULL ? 0 : partial->pt_argc))
{
EMSG(_("E699: Too many arguments"));
break;
if (item == NULL)
r = call_func(name, (int)STRLEN(name), rettv, argc, argv,
curwin->w_cursor.lnum, curwin->w_cursor.lnum,
- &dummy, TRUE, selfdict);
+ &dummy, TRUE, partial, selfdict);
/* Free the arguments. */
while (argc > 0)
}
/*
- * "call(func, arglist)" function
+ * "call(func, arglist [, dict])" function
*/
static void
f_call(typval_T *argvars, typval_T *rettv)
{
char_u *func;
+ partial_T *partial = NULL;
dict_T *selfdict = NULL;
if (argvars[1].v_type != VAR_LIST)
if (argvars[0].v_type == VAR_FUNC)
func = argvars[0].vval.v_string;
+ else if (argvars[0].v_type == VAR_PARTIAL)
+ {
+ partial = argvars[0].vval.v_partial;
+ func = partial->pt_name;
+ }
else
func = get_tv_string(&argvars[0]);
if (*func == NUL)
selfdict = argvars[2].vval.v_dict;
}
- (void)func_call(func, &argvars[1], selfdict, rettv);
+ (void)func_call(func, &argvars[1], partial, selfdict, rettv);
}
#ifdef FEAT_FLOAT
n = argvars[0].vval.v_string == NULL
|| *argvars[0].vval.v_string == NUL;
break;
+ case VAR_PARTIAL:
+ n = FALSE;
+ break;
case VAR_NUMBER:
n = argvars[0].vval.v_number == 0;
break;
f_function(typval_T *argvars, typval_T *rettv)
{
char_u *s;
+ char_u *name;
s = get_tv_string(&argvars[0]);
if (s == NULL || *s == NUL || VIM_ISDIGIT(*s))
* would also work, but some plugins depend on the name being
* printable text. */
sprintf(sid_buf, "<SNR>%ld_", (long)current_SID);
- rettv->vval.v_string =
- alloc((int)(STRLEN(sid_buf) + STRLEN(s + off) + 1));
- if (rettv->vval.v_string != NULL)
+ name = alloc((int)(STRLEN(sid_buf) + STRLEN(s + off) + 1));
+ if (name != NULL)
+ {
+ STRCPY(name, sid_buf);
+ STRCAT(name, s + off);
+ }
+ }
+ else
+ name = vim_strsave(s);
+
+ if (argvars[1].v_type != VAR_UNKNOWN)
+ {
+ partial_T *pt;
+ int dict_idx = 0;
+ int arg_idx = 0;
+
+ if (argvars[2].v_type != VAR_UNKNOWN)
+ {
+ /* function(name, [args], dict) */
+ arg_idx = 1;
+ dict_idx = 2;
+ }
+ else if (argvars[1].v_type == VAR_DICT)
+ /* function(name, dict) */
+ dict_idx = 1;
+ else
+ /* function(name, [args]) */
+ arg_idx = 1;
+ if (dict_idx > 0 && (argvars[dict_idx].v_type != VAR_DICT
+ || argvars[dict_idx].vval.v_dict == NULL))
+ {
+ EMSG(_("E922: expected a dict"));
+ vim_free(name);
+ return;
+ }
+ if (arg_idx > 0 && (argvars[arg_idx].v_type != VAR_LIST
+ || argvars[arg_idx].vval.v_list == NULL))
{
- STRCPY(rettv->vval.v_string, sid_buf);
- STRCAT(rettv->vval.v_string, s + off);
+ EMSG(_("E923: Second argument of function() must be a list or a dict"));
+ vim_free(name);
+ return;
}
+
+ pt = (partial_T *)alloc_clear(sizeof(partial_T));
+ if (pt != NULL)
+ {
+ if (arg_idx > 0)
+ {
+ list_T *list = argvars[arg_idx].vval.v_list;
+ listitem_T *li;
+ int i = 0;
+
+ pt->pt_argv = (typval_T *)alloc(
+ sizeof(typval_T) * list->lv_len);
+ if (pt->pt_argv == NULL)
+ {
+ vim_free(pt);
+ vim_free(name);
+ return;
+ }
+ else
+ {
+ pt->pt_argc = list->lv_len;
+ for (li = list->lv_first; li != NULL; li = li->li_next)
+ copy_tv(&li->li_tv, &pt->pt_argv[i++]);
+ }
+ }
+
+ if (dict_idx > 0)
+ {
+ pt->pt_dict = argvars[dict_idx].vval.v_dict;
+ ++pt->pt_dict->dv_refcount;
+ }
+
+ pt->pt_refcount = 1;
+ pt->pt_name = name;
+ func_ref(pt->pt_name);
+ }
+ rettv->v_type = VAR_PARTIAL;
+ rettv->vval.v_partial = pt;
}
else
- rettv->vval.v_string = vim_strsave(s);
- rettv->v_type = VAR_FUNC;
+ {
+ rettv->v_type = VAR_FUNC;
+ rettv->vval.v_string = name;
+ func_ref(name);
+ }
}
}
+ static void
+partial_free(partial_T *pt)
+{
+ int i;
+
+ for (i = 0; i < pt->pt_argc; ++i)
+ clear_tv(&pt->pt_argv[i]);
+ vim_free(pt->pt_argv);
+ func_unref(pt->pt_name);
+ vim_free(pt->pt_name);
+ vim_free(pt);
+}
+
+/*
+ * Unreference a closure: decrement the reference count and free it when it
+ * becomes zero.
+ */
+ void
+partial_unref(partial_T *pt)
+{
+ if (pt != NULL && --pt->pt_refcount <= 0)
+ partial_free(pt);
+}
+
/*
* "garbagecollect()" function
*/
case VAR_SPECIAL:
case VAR_FLOAT:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_JOB:
case VAR_CHANNEL:
EMSG(_("E701: Invalid type for len()"));
int item_compare_float;
#endif
char_u *item_compare_func;
+ partial_T *item_compare_partial;
dict_T *item_compare_selfdict;
int item_compare_func_err;
int item_compare_keep_zero;
typval_T rettv;
typval_T argv[3];
int dummy;
+ char_u *func_name;
+ partial_T *partial = sortinfo->item_compare_partial;
/* shortcut after failure in previous call; compare all items equal */
if (sortinfo->item_compare_func_err)
si1 = (sortItem_T *)s1;
si2 = (sortItem_T *)s2;
+ if (partial == NULL)
+ func_name = sortinfo->item_compare_func;
+ else
+ func_name = partial->pt_name;
+
/* Copy the values. This is needed to be able to set v_lock to VAR_FIXED
* in the copy without changing the original list items. */
copy_tv(&si1->item->li_tv, &argv[0]);
copy_tv(&si2->item->li_tv, &argv[1]);
rettv.v_type = VAR_UNKNOWN; /* clear_tv() uses this */
- res = call_func(sortinfo->item_compare_func,
- (int)STRLEN(sortinfo->item_compare_func),
+ res = call_func(func_name, (int)STRLEN(func_name),
&rettv, 2, argv, 0L, 0L, &dummy, TRUE,
- sortinfo->item_compare_selfdict);
+ partial, sortinfo->item_compare_selfdict);
clear_tv(&argv[0]);
clear_tv(&argv[1]);
info.item_compare_float = FALSE;
#endif
info.item_compare_func = NULL;
+ info.item_compare_partial = NULL;
info.item_compare_selfdict = NULL;
if (argvars[1].v_type != VAR_UNKNOWN)
{
/* optional second argument: {func} */
if (argvars[1].v_type == VAR_FUNC)
info.item_compare_func = argvars[1].vval.v_string;
+ else if (argvars[1].v_type == VAR_PARTIAL)
+ info.item_compare_partial = argvars[1].vval.v_partial;
else
{
int error = FALSE;
info.item_compare_func_err = FALSE;
info.item_compare_keep_zero = FALSE;
/* test the compare function */
- if (info.item_compare_func != NULL
+ if ((info.item_compare_func != NULL
+ || info.item_compare_partial != NULL)
&& item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
== ITEM_COMPARE_FAIL)
EMSG(_("E702: Sort compare function failed"));
/* Sort the array with item pointers. */
qsort((void *)ptrs, (size_t)len, sizeof(sortItem_T),
info.item_compare_func == NULL
+ && info.item_compare_partial == NULL
? item_compare : item_compare2);
if (!info.item_compare_func_err)
/* f_uniq(): ptrs will be a stack of items to remove */
info.item_compare_func_err = FALSE;
info.item_compare_keep_zero = TRUE;
- item_compare_func_ptr = info.item_compare_func
+ item_compare_func_ptr = info.item_compare_func != NULL
+ || info.item_compare_partial != NULL
? item_compare2 : item_compare;
for (li = l->lv_first; li != NULL && li->li_next != NULL;
break;
case VAR_JOB: n = 8; break;
case VAR_CHANNEL: n = 9; break;
+ case VAR_PARTIAL: n = 10; break;
case VAR_UNKNOWN:
EMSG2(_(e_intern2), "f_type(UNKNOWN)");
n = -1;
char_u *s;
int len;
typval_T functv;
+ partial_T *pt = NULL;
while (ret == OK
&& (**arg == '['
|| (**arg == '.' && rettv->v_type == VAR_DICT)
- || (**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC)))
+ || (**arg == '(' && (!evaluate || rettv->v_type == VAR_FUNC
+ || rettv->v_type == VAR_PARTIAL)))
&& !vim_iswhite(*(*arg - 1)))
{
if (**arg == '(')
rettv->v_type = VAR_UNKNOWN;
/* Invoke the function. Recursive! */
- s = functv.vval.v_string;
+ if (rettv->v_type == VAR_PARTIAL)
+ {
+ pt = functv.vval.v_partial;
+ s = pt->pt_name;
+ }
+ else
+ s = functv.vval.v_string;
}
else
s = (char_u *)"";
ret = get_func_tv(s, (int)STRLEN(s), rettv, arg,
curwin->w_cursor.lnum, curwin->w_cursor.lnum,
- &len, evaluate, selfdict);
+ &len, evaluate, pt, selfdict);
/* Clear the funcref afterwards, so that deleting it while
* evaluating the arguments is possible (see test55). */
case VAR_STRING:
vim_free(varp->vval.v_string);
break;
+ case VAR_PARTIAL:
+ partial_unref(varp->vval.v_partial);
+ break;
case VAR_LIST:
list_unref(varp->vval.v_list);
break;
vim_free(varp->vval.v_string);
varp->vval.v_string = NULL;
break;
+ case VAR_PARTIAL:
+ partial_unref(varp->vval.v_partial);
+ varp->vval.v_partial = NULL;
+ break;
case VAR_LIST:
list_unref(varp->vval.v_list);
varp->vval.v_list = NULL;
break;
#endif
case VAR_FUNC:
+ case VAR_PARTIAL:
EMSG(_("E703: Using a Funcref as a Number"));
break;
case VAR_STRING:
case VAR_FLOAT:
return varp->vval.v_float;
case VAR_FUNC:
+ case VAR_PARTIAL:
EMSG(_("E891: Using a Funcref as a Float"));
break;
case VAR_STRING:
sprintf((char *)buf, "%ld", (long)varp->vval.v_number);
return buf;
case VAR_FUNC:
+ case VAR_PARTIAL:
EMSG(_("E729: using Funcref as a String"));
break;
case VAR_LIST:
msg_advance(22);
if (type == VAR_NUMBER)
msg_putchar('#');
- else if (type == VAR_FUNC)
+ else if (type == VAR_FUNC || type == VAR_PARTIAL)
msg_putchar('*');
else if (type == VAR_LIST)
{
msg_outtrans(string);
- if (type == VAR_FUNC)
+ if (type == VAR_FUNC || type == VAR_PARTIAL)
msg_puts((char_u *)"()");
if (*first)
{
}
v = find_var_in_ht(ht, 0, varname, TRUE);
- if (tv->v_type == VAR_FUNC && var_check_func_name(name, v == NULL))
+ if ((tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
+ && var_check_func_name(name, v == NULL))
return;
if (v != NULL)
func_ref(to->vval.v_string);
}
break;
+ case VAR_PARTIAL:
+ if (from->vval.v_partial == NULL)
+ to->vval.v_partial = NULL;
+ else
+ {
+ to->vval.v_partial = from->vval.v_partial;
+ ++to->vval.v_partial->pt_refcount;
+ }
+ break;
case VAR_LIST:
if (from->vval.v_list == NULL)
to->vval.v_list = NULL;
case VAR_FLOAT:
case VAR_STRING:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_SPECIAL:
case VAR_JOB:
case VAR_CHANNEL:
char_u sid_buf[20];
int len;
lval_T lv;
+ partial_T *partial;
if (fdp != NULL)
vim_memset(fdp, 0, sizeof(funcdict_T));
if (lv.ll_exp_name != NULL)
{
len = (int)STRLEN(lv.ll_exp_name);
- name = deref_func_name(lv.ll_exp_name, &len, flags & TFN_NO_AUTOLOAD);
+ name = deref_func_name(lv.ll_exp_name, &len, &partial,
+ flags & TFN_NO_AUTOLOAD);
if (name == lv.ll_exp_name)
name = NULL;
}
else
{
len = (int)(end - *pp);
- name = deref_func_name(*pp, &len, flags & TFN_NO_AUTOLOAD);
+ name = deref_func_name(*pp, &len, &partial, flags & TFN_NO_AUTOLOAD);
if (name == *pp)
name = NULL;
}
case VAR_UNKNOWN:
case VAR_FUNC:
+ case VAR_PARTIAL:
case VAR_JOB:
case VAR_CHANNEL:
continue;
projects / vim / commitdiff