Merge remote-tracking branch 'vim/master'

Author: splhack

src/eval.c

@@ -3461,7 +3461,7 @@ ex_call(exarg_T *eap)
     int		doesrange;
     int		failed = FALSE;
     funcdict_T	fudi;
-    partial_T	*partial;
+    partial_T	*partial = NULL;
 
     if (eap->skip)
     {
@@ -3497,12 +3497,6 @@ ex_call(exarg_T *eap)
     name = deref_func_name(tofree, &len,
 				    partial != NULL ? NULL : &partial, FALSE);
 
-    /* When calling fdict.func(), where "func" is a partial, use "fdict"
-     * instead of the dict in the partial, for backwards compatibility.
-     * TODO: Do use the arguments in the partial? */
-    if (fudi.fd_dict != NULL)
-	partial = NULL;
-
     /* Skip white space to allow ":call func ()".  Not good, but required for
      * backward compatibility. */
     startarg = skipwhite(arg);
@@ -11814,6 +11808,7 @@ f_function(typval_T *argvars, typval_T *rettv)
     char_u	*s;
     char_u	*name;
     int		use_string = FALSE;
+    partial_T   *arg_pt = NULL;
 
     if (argvars[0].v_type == VAR_FUNC)
     {
@@ -11822,8 +11817,11 @@ f_function(typval_T *argvars, typval_T *rettv)
     }
     else if (argvars[0].v_type == VAR_PARTIAL
 					 && argvars[0].vval.v_partial != NULL)
+    {
 	/* function(dict.MyFunc, [arg]) */
-	s = argvars[0].vval.v_partial->pt_name;
+	arg_pt = argvars[0].vval.v_partial;
+	s = arg_pt->pt_name;
+    }
     else
     {
 	/* function('MyFunc', [arg], dict) */
@@ -11901,19 +11899,27 @@ f_function(typval_T *argvars, typval_T *rettv)
 		    arg_idx = 0;
 	    }
 	}
-	if (dict_idx > 0 || arg_idx > 0)
+	if (dict_idx > 0 || arg_idx > 0 || arg_pt != NULL)
 	{
 	    partial_T	*pt = (partial_T *)alloc_clear(sizeof(partial_T));
 
+	    /* result is a VAR_PARTIAL */
 	    if (pt != NULL)
 	    {
-		if (arg_idx > 0)
+		if (arg_idx > 0 || (arg_pt != NULL && arg_pt->pt_argc > 0))
 		{
 		    listitem_T	*li;
 		    int		i = 0;
-
+		    int		arg_len = 0;
+		    int		lv_len = 0;
+
+		    if (arg_pt != NULL)
+			arg_len = arg_pt->pt_argc;
+		    if (list != NULL)
+			lv_len = list->lv_len;
+		    pt->pt_argc = arg_len + lv_len;
 		    pt->pt_argv = (typval_T *)alloc(
-					     sizeof(typval_T) * list->lv_len);
+					      sizeof(typval_T) * pt->pt_argc);
 		    if (pt->pt_argv == NULL)
 		    {
 			vim_free(pt);
@@ -11922,9 +11928,12 @@ f_function(typval_T *argvars, typval_T *rettv)
 		    }
 		    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++]);
+			for (i = 0; i < arg_len; i++)
+			    copy_tv(&arg_pt->pt_argv[i], &pt->pt_argv[i]);
+			if (lv_len > 0)
+			    for (li = list->lv_first; li != NULL;
+							     li = li->li_next)
+				copy_tv(&li->li_tv, &pt->pt_argv[i++]);
 		    }
 		}
 
@@ -11935,10 +11944,11 @@ f_function(typval_T *argvars, typval_T *rettv)
 		    pt->pt_dict = argvars[dict_idx].vval.v_dict;
 		    ++pt->pt_dict->dv_refcount;
 		}
-		else if (argvars[0].v_type == VAR_PARTIAL)
+		else if (arg_pt != NULL)
 		{
-		    pt->pt_dict = argvars[0].vval.v_partial->pt_dict;
-		    ++pt->pt_dict->dv_refcount;
+		    pt->pt_dict = arg_pt->pt_dict;
+		    if (pt->pt_dict != NULL)
+			++pt->pt_dict->dv_refcount;
 		}
 
 		pt->pt_refcount = 1;
@@ -11950,6 +11960,7 @@ f_function(typval_T *argvars, typval_T *rettv)
 	}
 	else
 	{
+	    /* result is a VAR_FUNC */
 	    rettv->v_type = VAR_FUNC;
 	    rettv->vval.v_string = name;
 	    func_ref(name);
@@ -21744,17 +21755,18 @@ handle_subscript(
 	}
     }
 
-    if (rettv->v_type == VAR_FUNC && selfdict != NULL)
+    if ((rettv->v_type == VAR_FUNC || rettv->v_type == VAR_PARTIAL)
+							  && selfdict != NULL)
     {
-	char_u	    *fname;
+	char_u	    *fname = rettv->v_type == VAR_FUNC ? rettv->vval.v_string
+					     : rettv->vval.v_partial->pt_name;
 	char_u	    *tofree = NULL;
 	ufunc_T	    *fp;
 	char_u	    fname_buf[FLEN_FIXED + 1];
 	int	    error;
 
 	/* Translate "s:func" to the stored function name. */
-	fname = fname_trans_sid(rettv->vval.v_string, fname_buf,
-							     &tofree, &error);
+	fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
 	fp = find_func(fname);
 	vim_free(tofree);
 
@@ -21768,7 +21780,34 @@ handle_subscript(
 		pt->pt_refcount = 1;
 		pt->pt_dict = selfdict;
 		selfdict = NULL;
-		pt->pt_name = rettv->vval.v_string;
+		if (rettv->v_type == VAR_FUNC)
+		{
+		    /* just a function: use selfdict */
+		    pt->pt_name = rettv->vval.v_string;
+		}
+		else
+		{
+		    partial_T	*ret_pt = rettv->vval.v_partial;
+		    int		i;
+
+		    /* partial: use selfdict and copy args */
+		    pt->pt_name = vim_strsave(ret_pt->pt_name);
+		    if (ret_pt->pt_argc > 0)
+		    {
+			pt->pt_argv = (typval_T *)alloc(
+					  sizeof(typval_T) * ret_pt->pt_argc);
+			if (pt->pt_argv == NULL)
+			    /* out of memory: drop the arguments */
+			    pt->pt_argc = 0;
+			else
+			{
+			    pt->pt_argc = ret_pt->pt_argc;
+			    for (i = 0; i < pt->pt_argc; i++)
+				copy_tv(&ret_pt->pt_argv[i], &pt->pt_argv[i]);
+			}
+		    }
+		    partial_unref(ret_pt);
+		}
 		func_ref(pt->pt_name);
 		rettv->v_type = VAR_PARTIAL;
 		rettv->vval.v_partial = pt;
@@ -23920,6 +23959,14 @@ trans_function_name(
 	    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);
+	    *pp = end;
+	    if (partial != NULL)
+		*partial = lv.ll_tv->vval.v_partial;
+	}
 	else
 	{
 	    if (!skip && !(flags & TFN_QUIET) && (fdp == NULL

src/ex_cmds2.c

@@ -3345,7 +3345,7 @@ do_in_runtimepath(
 
     if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_START))
     {
-	len = STRLEN(start_dir) + STRLEN(name);
+	len = (int)(STRLEN(start_dir) + STRLEN(name));
 	s = alloc(len);
 	if (s == NULL)
 	    return FAIL;
@@ -3356,7 +3356,7 @@ do_in_runtimepath(
 
     if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_OPT))
     {
-	len = STRLEN(opt_dir) + STRLEN(name);
+	len = (int)(STRLEN(opt_dir) + STRLEN(name));
 	s = alloc(len);
 	if (s == NULL)
 	    return FAIL;

src/os_win32.c

@@ -214,7 +214,6 @@ static void standend(void);
 static void visual_bell(void);
 static void cursor_visible(BOOL fVisible);
 static DWORD write_chars(char_u *pchBuf, DWORD cbToWrite);
-static WCHAR tgetch(int *pmodifiers, WCHAR *pch2);
 static void create_conin(void);
 static int s_cursor_visible = TRUE;
 static int did_create_conin = FALSE;
@@ -1502,6 +1501,21 @@ WaitForChar(long msec)
 				    && (msec < 0 || (long)dwWaitTime > p_mzq))
 		dwWaitTime = p_mzq; /* don't wait longer than 'mzquantum' */
 #endif
+#ifdef FEAT_TIMERS
+	    {
+		long	due_time;
+
+		/* When waiting very briefly don't trigger timers. */
+		if (dwWaitTime > 10)
+		{
+		    /* Trigger timers and then get the time in msec until the
+		     * next one is due.  Wait up to that time. */
+		    due_time = check_due_timer();
+		    if (due_time > 0 && dwWaitTime > (DWORD)due_time)
+			dwWaitTime = due_time;
+		}
+	    }
+#endif
 #ifdef FEAT_CLIENTSERVER
 	    /* Wait for either an event on the console input or a message in
 	     * the client-server window. */
@@ -1604,7 +1618,7 @@ create_conin(void)
 }
 
 /*
- * Get a keystroke or a mouse event
+ * Get a keystroke or a mouse event, use a blocking wait.
  */
     static WCHAR
 tgetch(int *pmodifiers, WCHAR *pch2)
@@ -6074,7 +6088,7 @@ mch_write(
 
 
 /*
- * Delay for half a second.
+ * Delay for "msec" milliseconds.
  */
 /*ARGSUSED*/
     void

src/testdir/Make_all.mak

@@ -79,7 +79,6 @@ SCRIPTS_ALL = \
 	test93.out \
 	test94.out \
 	test95.out \
-	test96.out \
 	test98.out \
 	test99.out \
 	test101.out \