vim: src/eval.c comparison

comparison src/eval.c @ 8538:c337c813c64d v7.4.1559

commit https://github.com/vim/vim/commit/1735bc988c546cc962c5f94792815b4d7cb79710 Author: Bram Moolenaar <Bram@vim.org> Date: Mon Mar 14 23:05:14 2016 +0100 patch 7.4.1559 Problem: Passing cookie to a callback is clumsy. Solution: Change function() to take arguments and return a partial.

author	Christian Brabandt <cb@256bit.org>
date	Mon, 14 Mar 2016 23:15:05 +0100
parents	09041d2fd7d0
children	24db3583c496

comparison

equal deleted inserted replaced

-:cc20abebafa3
+:c337c813c64d
 static char_u *echo_string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);
 static char_u *tv2string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);
 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 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, dict_T *selfdict);
+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);
 #ifdef FEAT_FLOAT
 static void f_abs(typval_T *argvars, typval_T *rettv);
 }
 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;
 	restore_funccal(save_funccalp);
 }
 	switch (tv1->v_type)
 	{
 	    case VAR_UNKNOWN:
 	    case VAR_DICT:
 	    case VAR_FUNC:
+	    case VAR_PARTIAL:
 	    case VAR_SPECIAL:
 	    case VAR_JOB:
 	    case VAR_CHANNEL:
 		break;
 typval_T	rettv;
 linenr_T	lnum;
 int		doesrange;
 int		failed = FALSE;
 funcdict_T	fudi;
+partial_T	*partial;
 if (eap->skip)
 {
 	/* trans_function_name() doesn't work well when skipping, use eval0()
 	 * instead to skip to any following command, e.g. for:
 if (fudi.fd_dict != NULL)
 	++fudi.fd_dict->dv_refcount;
 /* 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. */
 startarg = skipwhite(arg);
 rettv.v_type = VAR_UNKNOWN;	/* clear_tv() uses this */
 #endif
 	}
 	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_UNKNOWN:
 	case VAR_NUMBER:
 	case VAR_STRING:
 	case VAR_FUNC:
+	case VAR_PARTIAL:
 	case VAR_FLOAT:
 	case VAR_SPECIAL:
 	case VAR_JOB:
 	case VAR_CHANNEL:
 	    break;
 		    if (type == TYPE_NEQUAL)
 			n1 = !n1;
 		}
 	    }
-	    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))
 		{
 		    if (rettv->v_type != var2.v_type)
 			EMSG(_("E694: Invalid operation for Funcrefs"));
 		    clear_tv(rettv);
 		    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. */
 		    if (rettv->vval.v_string == NULL
 						|| var2.vval.v_string == NULL)
 			n1 = FALSE;
 		    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 one of the two variables is a float, compare as a float.
 	    ret = FAIL;
 	else
 	{
 	    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
 		 * what follows. So set it here. */
 		if (rettv->v_type == VAR_UNKNOWN && !evaluate && **arg == '(')
 char_u	*key = NULL;
 switch (rettv->v_type)
 {
 	case VAR_FUNC:
+	case VAR_PARTIAL:
 	    if (verbose)
 		EMSG(_("E695: Cannot index a Funcref"));
 	    return FAIL;
 	case VAR_FLOAT:
 #ifdef FEAT_FLOAT
 	switch (rettv->v_type)
 	{
 	    case VAR_UNKNOWN:
 	    case VAR_FUNC:
+	    case VAR_PARTIAL:
 	    case VAR_FLOAT:
 	    case VAR_SPECIAL:
 	    case VAR_JOB:
 	    case VAR_CHANNEL:
 		break; /* not evaluating, skipping over subscript */
 	case VAR_FUNC:
 	    return (tv1->vval.v_string != NULL
 		    && 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;
 	case VAR_STRING:
 	    s1 = get_tv_string_buf(tv1, buf1);
 	case VAR_FUNC:
 	    *tofree = NULL;
 	    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)
 	    {
 		*tofree = NULL;
 		r = NULL;
 switch (tv->v_type)
 {
 	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;
 	case VAR_FLOAT:
 #ifdef FEAT_FLOAT
 {"foldclosedend",	1, 1, f_foldclosedend},
 {"foldlevel",	1, 1, f_foldlevel},
 {"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},
 {"getbufvar",	2, 3, f_getbufvar},
 {"getchar",		0, 1, f_getchar},
 }
 /*
 * 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);
 name[*lenp] = cc;
 	    *lenp = 0;
 	    return (char_u *)"";	/* just in case */
 	}
 	*lenp = (int)STRLEN(v->di_tv.vval.v_string);
 	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;
 }
 char_u	**arg,		/* argument, pointing to the '(' */
 linenr_T	firstline,	/* first line of range */
 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;
 int		ret = OK;
 typval_T	argvars[MAX_FUNC_ARGS + 1];	/* vars for arguments */
 /*
 * 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)
 	    break;
 	if (eval1(&argp, &argvars[argcount], evaluate) == FAIL)
 else
 	ret = FAIL;
 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)
 	    emsg_funcname(N_("E740: Too many arguments for function %s"), name);
 	else
 int
 call_func(
 char_u	*funcname,	/* name of the function */
 int		len,		/* length of "name" */
 typval_T	*rettv,		/* return value goes here */
-int		argcount,	/* number of "argvars" */
+int		argcount_in,	/* number of "argvars" */
-typval_T	*argvars,	/* vars for arguments, must have "argcount"
+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_TOOMANY	1
 #define ERROR_TOOFEW	2
 #define ERROR_SCRIPT	3
 #define ERROR_DICT	4
 #define ERROR_NONE	5
 #define ERROR_OTHER	6
+#define ERROR_BOTH	7
 int		error = ERROR_NONE;
 int		i;
 int		llen;
 ufunc_T	*fp;
 #define FLEN_FIXED 40
 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. */
 name = vim_strnsave(funcname, len);
 if (name == NULL)
 }
 else
 	fname = name;
 *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)
 {
 		    break;
 	    case ERROR_DICT:
 		    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);
 return ret;
 int
 func_call(
 char_u	*name,
 typval_T	*args,
+partial_T	*partial,
 dict_T	*selfdict,
 typval_T	*rettv)
 {
 listitem_T	*item;
 typval_T	argv[MAX_FUNC_ARGS + 1];
 int		r = 0;
 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;
 	}
 	/* Make a copy of each argument.  This is needed to be able to set
 }
 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)
 	clear_tv(&argv[--argc]);
 return r;
 }
 /*
-* "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)
 {
 	EMSG(_(e_listreq));
 if (argvars[1].vval.v_list == NULL)
 	return;
 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)
 	return;		/* type error or empty name */
 	    return;
 	}
 	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
 /*
 * "ceil({float})" function
 {
 	case VAR_STRING:
 	case VAR_FUNC:
 	    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;
 	case VAR_FLOAT:
 */
 static void
 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))
 	EMSG2(_(e_invarg2), s);
 /* Don't check an autoload name for existence here. */
 	    /* Expand s: and <SID> into <SNR>nr_, so that the function can
 	     * also be called from another script. Using trans_function_name()
 	     * 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 =
+	    name = alloc((int)(STRLEN(sid_buf) + STRLEN(s + off) + 1));
-			    alloc((int)(STRLEN(sid_buf) + STRLEN(s + off) + 1));
+	    if (name != NULL)
-	    if (rettv->vval.v_string != NULL)
 	    {
-		STRCPY(rettv->vval.v_string, sid_buf);
+		STRCPY(name, sid_buf);
-		STRCAT(rettv->vval.v_string, s + off);
+		STRCAT(name, s + off);
 	    }
 	}
 	else
-	    rettv->vval.v_string = vim_strsave(s);
+	    name = vim_strsave(s);
-	rettv->v_type = VAR_FUNC;
-}
+	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))
+	    {
+		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->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
 */
 	    break;
 	case VAR_UNKNOWN:
 	case VAR_SPECIAL:
 	case VAR_FLOAT:
 	case VAR_FUNC:
+	case VAR_PARTIAL:
 	case VAR_JOB:
 	case VAR_CHANNEL:
 	    EMSG(_("E701: Invalid type for len()"));
 	    break;
 }
 int		item_compare_numbers;
 #ifdef FEAT_FLOAT
 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;
 } sortinfo_T;
 static sortinfo_T	*sortinfo = NULL;
 sortItem_T  *si1, *si2;
 int		res;
 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)
 	return 0;
 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,
+res = call_func(func_name, (int)STRLEN(func_name),
-				 (int)STRLEN(sortinfo->item_compare_func),
 				 &rettv, 2, argv, 0L, 0L, &dummy, TRUE,
-				 sortinfo->item_compare_selfdict);
+				 partial, sortinfo->item_compare_selfdict);
 clear_tv(&argv[0]);
 clear_tv(&argv[1]);
 if (res == FAIL)
 	res = ITEM_COMPARE_FAIL;
 	info.item_compare_numbers = FALSE;
 #ifdef FEAT_FLOAT
 	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;
 		i = get_tv_number_chk(&argvars[1], &error);
 	    }
 	    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"));
 	    else
 	    {
 		/* 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)
 		{
 		    /* Clear the List and append the items in sorted order. */
 	    int	(*item_compare_func_ptr)(const void *, const void *);
 	    /* 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;
 							     li = li->li_next)
 	    {
 	     else
 		 n = 7;
 	     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;
 	     break;
 }
 int		ret = OK;
 dict_T	*selfdict = NULL;
 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 == '(')
 	{
 	    /* need to copy the funcref so that we can clear rettv */
 	    {
 		functv = *rettv;
 		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). */
 	    if (evaluate)
 		clear_tv(&functv);
 		func_unref(varp->vval.v_string);
 		/*FALLTHROUGH*/
 	    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;
 	    case VAR_DICT:
 		dict_unref(varp->vval.v_dict);
 		func_unref(varp->vval.v_string);
 		/*FALLTHROUGH*/
 	    case VAR_STRING:
 		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;
 #ifdef FEAT_FLOAT
 	    EMSG(_("E805: Using a Float as a Number"));
 	    break;
 #endif
 	case VAR_FUNC:
+	case VAR_PARTIAL:
 	    EMSG(_("E703: Using a Funcref as a Number"));
 	    break;
 	case VAR_STRING:
 	    if (varp->vval.v_string != NULL)
 		vim_str2nr(varp->vval.v_string, NULL, NULL,
 	case VAR_NUMBER:
 	    return (float_T)(varp->vval.v_number);
 	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:
 	    EMSG(_("E892: Using a String as a Float"));
 	    break;
 {
 	case VAR_NUMBER:
 	    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:
 	    EMSG(_("E730: using List as a String"));
 	    break;
 	msg_puts(name);
 msg_putchar(' ');
 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_putchar('[');
 	if (*string == '[')
 else
 	msg_putchar(' ');
 msg_outtrans(string);
-if (type == VAR_FUNC)
+if (type == VAR_FUNC || type == VAR_PARTIAL)
 	msg_puts((char_u *)"()");
 if (*first)
 {
 	msg_clr_eos();
 	*first = FALSE;
 	EMSG2(_(e_illvar), name);
 	return;
 }
 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)
 {
 	/* existing variable, need to clear the value */
 		to->vval.v_string = vim_strsave(from->vval.v_string);
 		if (from->v_type == VAR_FUNC)
 		    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;
 	    else
 	    {
 {
 	case VAR_NUMBER:
 	case VAR_FLOAT:
 	case VAR_STRING:
 	case VAR_FUNC:
+	case VAR_PARTIAL:
 	case VAR_SPECIAL:
 	case VAR_JOB:
 	case VAR_CHANNEL:
 	    copy_tv(from, to);
 	    break;
 char_u	*end;
 int		lead;
 char_u	sid_buf[20];
 int		len;
 lval_T	lv;
+partial_T	*partial;
 if (fdp != NULL)
 	vim_memset(fdp, 0, sizeof(funcdict_T));
 start = *pp;
 /* Check if the name is a Funcref.  If so, use the value. */
 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;
 }
 if (name != NULL)
 {
 		    case VAR_LIST:   s = "LIS"; break;
 		    case VAR_SPECIAL: s = "XPL"; break;
 		    case VAR_UNKNOWN:
 		    case VAR_FUNC:
+		    case VAR_PARTIAL:
 		    case VAR_JOB:
 		    case VAR_CHANNEL:
 				     continue;
 		}
 		fprintf(fp, "!%s\t%s\t", this_var->di_key, s);

Mercurial > vim

comparison src/eval.c @ 8538:c337c813c64d v7.4.1559