Update vim to 8.1.1471

1 files changed, 688 insertions, 0 deletions

diff --git a/data/vim/patches/8.1.0834 b/data/vim/patches/8.1.0834
new file mode 100644
index 000000000..f5de64ec5
--- /dev/null
+++ b/data/vim/patches/8.1.0834
@@ -0,0 +1,688 @@
+To: vim_dev@googlegroups.com
+Subject: Patch 8.1.0834
+Fcc: outbox
+From: Bram Moolenaar <Bram@moolenaar.net>
+Mime-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+------------
+
+Patch 8.1.0834
+Problem:    GUI may wait too long before dealing with messages.  Returning
+            early may cause a mapping to time out.
+Solution:   Use the waiting loop from Unix also for the GUI.
+            (closes #3817, closes #3824)
+Files:	    src/ui.c, src/proto/ui.pro, src/os_unix.c, src/gui.c,
+            src/testdir/screendump.vim
+
+
+*** ../vim-8.1.0833/src/ui.c	2019-01-26 17:28:22.236599060 +0100
+--- src/ui.c	2019-01-27 16:50:31.054860125 +0100
+***************
+*** 178,183 ****
+--- 178,225 ----
+  	    ctrl_c_interrupts = FALSE;
+      }
+  
++     /*
++      * Here we call gui_inchar() or mch_inchar(), the GUI or machine-dependent
++      * input function.  The functionality they implement is like this:
++      *
++      * while (not timed out)
++      * {
++      *    handle-resize;
++      *    parse-queued-messages;
++      *    if (waited for 'updatetime')
++      *       trigger-cursorhold;
++      *    ui_wait_for_chars_or_timer()
++      *    if (character available)
++      *      break;
++      * }
++      *
++      * ui_wait_for_chars_or_timer() does:
++      *
++      * while (not timed out)
++      * {
++      *     if (any-timer-triggered)
++      *        invoke-timer-callback;
++      *     wait-for-character();
++      *     if (character available)
++      *        break;
++      * }
++      *
++      * wait-for-character() does:
++      * while (not timed out)
++      * {
++      *     Wait for event;
++      *     if (something on channel)
++      *        read/write channel;
++      *     else if (resized)
++      *        handle_resize();
++      *     else if (system event)
++      *        deal-with-system-event;
++      *     else if (character available)
++      *        break;
++      * }
++      *
++      */
++ 
+  #ifdef FEAT_GUI
+      if (gui.in_use)
+  	retval = gui_inchar(buf, maxlen, wtime, tb_change_cnt);
+***************
+*** 205,210 ****
+--- 247,422 ----
+      return retval;
+  }
+  
++ #if defined(UNIX) || defined(FEAT_GUI) || defined(PROTO)
++ /*
++  * Common code for mch_inchar() and gui_inchar(): Wait for a while or
++  * indefinitely until characters are available, dealing with timers and
++  * messages on channels.
++  *
++  * "buf" may be NULL if the available characters are not to be returned, only
++  * check if they are available.
++  *
++  * Return the number of characters that are available.
++  * If "wtime" == 0 do not wait for characters.
++  * If "wtime" == n wait a short time for characters.
++  * If "wtime" == -1 wait forever for characters.
++  */
++     int
++ inchar_loop(
++     char_u	*buf,
++     int		maxlen,
++     long	wtime,	    // don't use "time", MIPS cannot handle it
++     int		tb_change_cnt,
++     int		(*wait_func)(long wtime, int *interrupted, int ignore_input),
++     int		(*resize_func)(int check_only))
++ {
++     int		len;
++     int		interrupted = FALSE;
++     int		did_start_blocking = FALSE;
++     long	wait_time;
++     long	elapsed_time = 0;
++ #ifdef ELAPSED_FUNC
++     elapsed_T	start_tv;
++ 
++     ELAPSED_INIT(start_tv);
++ #endif
++ 
++     /* repeat until we got a character or waited long enough */
++     for (;;)
++     {
++ 	/* Check if window changed size while we were busy, perhaps the ":set
++ 	 * columns=99" command was used. */
++ 	if (resize_func != NULL)
++ 	    resize_func(FALSE);
++ 
++ #ifdef MESSAGE_QUEUE
++ 	// Only process messages when waiting.
++ 	if (wtime != 0)
++ 	{
++ 	    parse_queued_messages();
++ 	    // If input was put directly in typeahead buffer bail out here.
++ 	    if (typebuf_changed(tb_change_cnt))
++ 		return 0;
++ 	}
++ #endif
++ 	if (wtime < 0 && did_start_blocking)
++ 	    // blocking and already waited for p_ut
++ 	    wait_time = -1;
++ 	else
++ 	{
++ 	    if (wtime >= 0)
++ 		wait_time = wtime;
++ 	    else
++ 		// going to block after p_ut
++ 		wait_time = p_ut;
++ #ifdef ELAPSED_FUNC
++ 	    elapsed_time = ELAPSED_FUNC(start_tv);
++ #endif
++ 	    wait_time -= elapsed_time;
++ 	    if (wait_time <= 0)
++ 	    {
++ 		if (wtime >= 0)
++ 		    // no character available within "wtime"
++ 		    return 0;
++ 
++ 		// No character available within 'updatetime'.
++ 		did_start_blocking = TRUE;
++ 		if (trigger_cursorhold() && maxlen >= 3
++ 					    && !typebuf_changed(tb_change_cnt))
++ 		{
++ 		    // Put K_CURSORHOLD in the input buffer or return it.
++ 		    if (buf == NULL)
++ 		    {
++ 			char_u	ibuf[3];
++ 
++ 			ibuf[0] = CSI;
++ 			ibuf[1] = KS_EXTRA;
++ 			ibuf[2] = (int)KE_CURSORHOLD;
++ 			add_to_input_buf(ibuf, 3);
++ 		    }
++ 		    else
++ 		    {
++ 			buf[0] = K_SPECIAL;
++ 			buf[1] = KS_EXTRA;
++ 			buf[2] = (int)KE_CURSORHOLD;
++ 		    }
++ 		    return 3;
++ 		}
++ 
++ 		// There is no character available within 'updatetime' seconds:
++ 		// flush all the swap files to disk.  Also done when
++ 		// interrupted by SIGWINCH.
++ 		before_blocking();
++ 		continue;
++ 	    }
++ 	}
++ 
++ #ifdef FEAT_JOB_CHANNEL
++ 	if (wait_time < 0 || wait_time > 100L)
++ 	{
++ 	    // Checking if a job ended requires polling.  Do this at least
++ 	    // every 100 msec.
++ 	    if (has_pending_job())
++ 		wait_time = 100L;
++ 
++ 	    // If there is readahead then parse_queued_messages() timed out and
++ 	    // we should call it again soon.
++ 	    if (channel_any_readahead())
++ 		wait_time = 10L;
++ 	}
++ #endif
++ #ifdef FEAT_BEVAL_GUI
++ 	if (p_beval && wait_time > 100L)
++ 	    // The 'balloonexpr' may indirectly invoke a callback while waiting
++ 	    // for a character, need to check often.
++ 	    wait_time = 100L;
++ #endif
++ 
++ 	// Wait for a character to be typed or another event, such as the winch
++ 	// signal or an event on the monitored file descriptors.
++ 	if (wait_func(wait_time, &interrupted, FALSE))
++ 	{
++ 	    // If input was put directly in typeahead buffer bail out here.
++ 	    if (typebuf_changed(tb_change_cnt))
++ 		return 0;
++ 
++ 	    // We might have something to return now.
++ 	    if (buf == NULL)
++ 		// "buf" is NULL, we were just waiting, not actually getting
++ 		// input.
++ 		return input_available();
++ 
++ 	    len = read_from_input_buf(buf, (long)maxlen);
++ 	    if (len > 0)
++ 		return len;
++ 	    continue;
++ 	}
++ 	// Timed out or interrupted with no character available.
++ 
++ #ifndef ELAPSED_FUNC
++ 	// estimate the elapsed time
++ 	elapsed_time += wait_time;
++ #endif
++ 
++ 	if ((resize_func != NULL && resize_func(TRUE))
++ #ifdef FEAT_CLIENTSERVER
++ 		|| server_waiting()
++ #endif
++ #ifdef MESSAGE_QUEUE
++ 		|| interrupted
++ #endif
++ 		|| wait_time > 0
++ 		|| (wtime < 0 && !did_start_blocking))
++ 	    // no character available, but something to be done, keep going
++ 	    continue;
++ 
++ 	// no character available or interrupted, return zero
++ 	break;
++     }
++     return 0;
++ }
++ #endif
++ 
+  #if defined(FEAT_TIMERS) || defined(PROTO)
+  /*
+   * Wait for a timer to fire or "wait_func" to return non-zero.
+*** ../vim-8.1.0833/src/proto/ui.pro	2018-05-17 13:52:54.000000000 +0200
+--- src/proto/ui.pro	2019-01-26 22:35:56.703647735 +0100
+***************
+*** 2,7 ****
+--- 2,8 ----
+  void ui_write(char_u *s, int len);
+  void ui_inchar_undo(char_u *s, int len);
+  int ui_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
++ int inchar_loop(char_u *buf, int maxlen, long wtime, int tb_change_cnt, int (*wait_func)(long wtime, int *interrupted, int ignore_input), int (*resize_func)(int check_only));
+  int ui_wait_for_chars_or_timer(long wtime, int (*wait_func)(long wtime, int *interrupted, int ignore_input), int *interrupted, int ignore_input);
+  int ui_char_avail(void);
+  void ui_delay(long msec, int ignoreinput);
+*** ../vim-8.1.0833/src/os_unix.c	2019-01-26 15:12:52.558260916 +0100
+--- src/os_unix.c	2019-01-26 22:36:20.799486197 +0100
+***************
+*** 356,361 ****
+--- 356,376 ----
+  }
+  
+  /*
++  * Function passed to inchar_loop() to handle window resizing.
++  * If "check_only" is TRUE: Return whether there was a resize.
++  * If "check_only" is FALSE: Deal with the window resized.
++  */
++     static int
++ resize_func(int check_only)
++ {
++     if (check_only)
++ 	return do_resize;
++     while (do_resize)
++ 	handle_resize();
++     return FALSE;
++ }
++ 
++ /*
+   * mch_inchar(): low level input function.
+   * Get a characters from the keyboard.
+   * Return the number of characters that are available.
+***************
+*** 370,507 ****
+      long	wtime,	    /* don't use "time", MIPS cannot handle it */
+      int		tb_change_cnt)
+  {
+!     int		len;
+!     int		interrupted = FALSE;
+!     int		did_start_blocking = FALSE;
+!     long	wait_time;
+!     long	elapsed_time = 0;
+! #ifdef ELAPSED_FUNC
+!     elapsed_T	start_tv;
+! 
+!     ELAPSED_INIT(start_tv);
+! #endif
+! 
+!     /* repeat until we got a character or waited long enough */
+!     for (;;)
+!     {
+! 	/* Check if window changed size while we were busy, perhaps the ":set
+! 	 * columns=99" command was used. */
+! 	while (do_resize)
+! 	    handle_resize();
+! 
+! #ifdef MESSAGE_QUEUE
+! 	// Only process messages when waiting.
+! 	if (wtime != 0)
+! 	{
+! 	    parse_queued_messages();
+! 	    // If input was put directly in typeahead buffer bail out here.
+! 	    if (typebuf_changed(tb_change_cnt))
+! 		return 0;
+! 	}
+! #endif
+! 	if (wtime < 0 && did_start_blocking)
+! 	    /* blocking and already waited for p_ut */
+! 	    wait_time = -1;
+! 	else
+! 	{
+! 	    if (wtime >= 0)
+! 		wait_time = wtime;
+! 	    else
+! 		/* going to block after p_ut */
+! 		wait_time = p_ut;
+! #ifdef ELAPSED_FUNC
+! 	    elapsed_time = ELAPSED_FUNC(start_tv);
+! #endif
+! 	    wait_time -= elapsed_time;
+! 	    if (wait_time < 0)
+! 	    {
+! 		if (wtime >= 0)
+! 		    /* no character available within "wtime" */
+! 		    return 0;
+! 
+! 		else
+! 		{
+! 		    /* no character available within 'updatetime' */
+! 		    did_start_blocking = TRUE;
+! 		    if (trigger_cursorhold() && maxlen >= 3
+! 					    && !typebuf_changed(tb_change_cnt))
+! 		    {
+! 			buf[0] = K_SPECIAL;
+! 			buf[1] = KS_EXTRA;
+! 			buf[2] = (int)KE_CURSORHOLD;
+! 			return 3;
+! 		    }
+! 		    /*
+! 		     * If there is no character available within 'updatetime'
+! 		     * seconds flush all the swap files to disk.
+! 		     * Also done when interrupted by SIGWINCH.
+! 		     */
+! 		    before_blocking();
+! 		    continue;
+! 		}
+! 	    }
+! 	}
+! 
+! #ifdef FEAT_JOB_CHANNEL
+! 	/* Checking if a job ended requires polling.  Do this every 100 msec. */
+! 	if (has_pending_job() && (wait_time < 0 || wait_time > 100L))
+! 	    wait_time = 100L;
+! 	/* If there is readahead then parse_queued_messages() timed out and we
+! 	 * should call it again soon. */
+! 	if ((wait_time < 0 || wait_time > 100L) && channel_any_readahead())
+! 	    wait_time = 10L;
+! #endif
+! #ifdef FEAT_BEVAL_GUI
+! 	if (p_beval && wait_time > 100L)
+! 	    /* The 'balloonexpr' may indirectly invoke a callback while waiting
+! 	     * for a character, need to check often. */
+! 	    wait_time = 100L;
+! #endif
+! 
+! 	/*
+! 	 * We want to be interrupted by the winch signal
+! 	 * or by an event on the monitored file descriptors.
+! 	 */
+! 	if (WaitForChar(wait_time, &interrupted, FALSE))
+! 	{
+! 	    /* If input was put directly in typeahead buffer bail out here. */
+! 	    if (typebuf_changed(tb_change_cnt))
+! 		return 0;
+! 
+! 	    /*
+! 	     * For some terminals we only get one character at a time.
+! 	     * We want the get all available characters, so we could keep on
+! 	     * trying until none is available
+! 	     * For some other terminals this is quite slow, that's why we don't
+! 	     * do it.
+! 	     */
+! 	    len = read_from_input_buf(buf, (long)maxlen);
+! 	    if (len > 0)
+! 		return len;
+! 	    continue;
+! 	}
+! 
+! 	/* no character available */
+! #ifndef ELAPSED_FUNC
+! 	/* estimate the elapsed time */
+! 	elapsed_time += wait_time;
+! #endif
+! 
+! 	if (do_resize	    /* interrupted by SIGWINCH signal */
+! #ifdef FEAT_CLIENTSERVER
+! 		|| server_waiting()
+! #endif
+! #ifdef MESSAGE_QUEUE
+! 		|| interrupted
+! #endif
+! 		|| wait_time > 0
+! 		|| (wtime < 0 && !did_start_blocking))
+! 	    continue;
+! 
+! 	/* no character available or interrupted */
+! 	break;
+!     }
+!     return 0;
+  }
+  
+      static void
+--- 385,392 ----
+      long	wtime,	    /* don't use "time", MIPS cannot handle it */
+      int		tb_change_cnt)
+  {
+!     return inchar_loop(buf, maxlen, wtime, tb_change_cnt,
+! 		       WaitForChar, resize_func);
+  }
+  
+      static void
+*** ../vim-8.1.0833/src/gui.c	2019-01-26 17:28:22.224599141 +0100
+--- src/gui.c	2019-01-26 23:17:38.097634554 +0100
+***************
+*** 2896,2905 ****
+   * or FAIL otherwise.
+   */
+      static int
+! gui_wait_for_chars_or_timer(long wtime)
+  {
+  #ifdef FEAT_TIMERS
+!     return ui_wait_for_chars_or_timer(wtime, gui_wait_for_chars_3, NULL, 0);
+  #else
+      return gui_mch_wait_for_chars(wtime);
+  #endif
+--- 2896,2909 ----
+   * or FAIL otherwise.
+   */
+      static int
+! gui_wait_for_chars_or_timer(
+! 	long wtime,
+! 	int *interrupted UNUSED,
+! 	int ignore_input UNUSED)
+  {
+  #ifdef FEAT_TIMERS
+!     return ui_wait_for_chars_or_timer(wtime, gui_wait_for_chars_3,
+! 						    interrupted, ignore_input);
+  #else
+      return gui_mch_wait_for_chars(wtime);
+  #endif
+***************
+*** 2907,3000 ****
+  
+  /*
+   * The main GUI input routine.	Waits for a character from the keyboard.
+!  * wtime == -1	    Wait forever.
+!  * wtime == 0	    Don't wait.
+!  * wtime > 0	    Wait wtime milliseconds for a character.
+!  * Returns OK if a character was found to be available within the given time,
+!  * or FAIL otherwise.
+   */
+!     int
+! gui_wait_for_chars(long wtime, int tb_change_cnt)
+  {
+!     int		retval;
+! #if defined(ELAPSED_FUNC)
+!     elapsed_T	start_tv;
+! #endif
+  
+  #ifdef FEAT_MENU
+!     /*
+!      * If we're going to wait a bit, update the menus and mouse shape for the
+!      * current State.
+!      */
+      if (wtime != 0)
+  	gui_update_menus(0);
+  #endif
+  
+      gui_mch_update();
+!     if (input_available())	/* Got char, return immediately */
+! 	return OK;
+!     if (wtime == 0)	/* Don't wait for char */
+! 	return FAIL;
+! 
+!     /* Before waiting, flush any output to the screen. */
+!     gui_mch_flush();
+! 
+!     if (wtime > 0)
+      {
+! 	/* Blink when waiting for a character.	Probably only does something
+! 	 * for showmatch() */
+! 	gui_mch_start_blink();
+! 	retval = gui_wait_for_chars_or_timer(wtime);
+! 	gui_mch_stop_blink(TRUE);
+! 	return retval;
+      }
+  
+! #if defined(ELAPSED_FUNC)
+!     ELAPSED_INIT(start_tv);
+! #endif
+  
+!     /*
+!      * While we are waiting indefinitely for a character, blink the cursor.
+!      */
+      gui_mch_start_blink();
+  
+!     retval = FAIL;
+!     /*
+!      * We may want to trigger the CursorHold event.  First wait for
+!      * 'updatetime' and if nothing is typed within that time, and feedkeys()
+!      * wasn't used, put the K_CURSORHOLD key in the input buffer.
+!      */
+!     if (gui_wait_for_chars_or_timer(p_ut) == OK)
+! 	retval = OK;
+!     else if (trigger_cursorhold()
+! #if defined(ELAPSED_FUNC)
+! 	    && ELAPSED_FUNC(start_tv) >= p_ut
+! #endif
+! 	    && typebuf.tb_change_cnt == tb_change_cnt)
+!     {
+! 	char_u	buf[3];
+! 
+! 	/* Put K_CURSORHOLD in the input buffer. */
+! 	buf[0] = CSI;
+! 	buf[1] = KS_EXTRA;
+! 	buf[2] = (int)KE_CURSORHOLD;
+! 	add_to_input_buf(buf, 3);
+! 
+! 	retval = OK;
+!     }
+! 
+!     if (retval == FAIL && typebuf.tb_change_cnt == tb_change_cnt)
+!     {
+! 	/* Blocking wait. */
+! 	before_blocking();
+! 	retval = gui_wait_for_chars_or_timer(-1L);
+!     }
+  
+      gui_mch_stop_blink(TRUE);
+      return retval;
+  }
+  
+  /*
+   * Equivalent of mch_inchar() for the GUI.
+   */
+      int
+--- 2911,2982 ----
+  
+  /*
+   * The main GUI input routine.	Waits for a character from the keyboard.
+!  * "wtime" == -1    Wait forever.
+!  * "wtime" == 0	    Don't wait.
+!  * "wtime" > 0	    Wait wtime milliseconds for a character.
+!  *
+!  * Returns the number of characters read or zero when timed out or interrupted.
+!  * "buf" may be NULL, in which case a non-zero number is returned if characters
+!  * are available.
+   */
+!     static int
+! gui_wait_for_chars_buf(
+!     char_u	*buf,
+!     int		maxlen,
+!     long	wtime,	    // don't use "time", MIPS cannot handle it
+!     int		tb_change_cnt)
+  {
+!     int	    retval;
+  
+  #ifdef FEAT_MENU
+!     // If we're going to wait a bit, update the menus and mouse shape for the
+!     // current State.
+      if (wtime != 0)
+  	gui_update_menus(0);
+  #endif
+  
+      gui_mch_update();
+!     if (input_available())	// Got char, return immediately
+      {
+! 	if (buf != NULL && !typebuf_changed(tb_change_cnt))
+! 	    return read_from_input_buf(buf, (long)maxlen);
+! 	return 0;
+      }
++     if (wtime == 0)		// Don't wait for char
++ 	return FAIL;
+  
+!     // Before waiting, flush any output to the screen.
+!     gui_mch_flush();
+  
+!     // Blink while waiting for a character.
+      gui_mch_start_blink();
+  
+!     // Common function to loop until "wtime" is met, while handling timers and
+!     // other callbacks.
+!     retval = inchar_loop(buf, maxlen, wtime, tb_change_cnt,
+! 			 gui_wait_for_chars_or_timer, NULL);
+  
+      gui_mch_stop_blink(TRUE);
++ 
+      return retval;
+  }
+  
+  /*
++  * Wait for a character from the keyboard without actually reading it.
++  * Also deals with timers.
++  * wtime == -1	    Wait forever.
++  * wtime == 0	    Don't wait.
++  * wtime > 0	    Wait wtime milliseconds for a character.
++  * Returns OK if a character was found to be available within the given time,
++  * or FAIL otherwise.
++  */
++     int
++ gui_wait_for_chars(long wtime, int tb_change_cnt)
++ {
++     return gui_wait_for_chars_buf(NULL, 0, wtime, tb_change_cnt);
++ }
++ 
++ /*
+   * Equivalent of mch_inchar() for the GUI.
+   */
+      int
+***************
+*** 3004,3013 ****
+      long    wtime,		/* milli seconds */
+      int	    tb_change_cnt)
+  {
+!     if (gui_wait_for_chars(wtime, tb_change_cnt)
+! 	    && !typebuf_changed(tb_change_cnt))
+! 	return read_from_input_buf(buf, (long)maxlen);
+!     return 0;
+  }
+  
+  /*
+--- 2986,2992 ----
+      long    wtime,		/* milli seconds */
+      int	    tb_change_cnt)
+  {
+!     return gui_wait_for_chars_buf(buf, maxlen, wtime, tb_change_cnt);
+  }
+  
+  /*
+*** ../vim-8.1.0833/src/testdir/screendump.vim	2018-12-04 22:24:12.193693584 +0100
+--- src/testdir/screendump.vim	2019-01-27 16:20:34.371242071 +0100
+***************
+*** 58,63 ****
+--- 58,67 ----
+    let cmd .= ' -v ' . a:arguments
+    let buf = term_start(cmd, {'curwin': 1, 'term_rows': rows, 'term_cols': cols})
+    if &termwinsize == ''
++     " in the GUI we may end up with a different size, try to set it.
++     if term_getsize(buf) != [rows, cols]
++       call term_setsize(buf, rows, cols)
++     endif
+      call assert_equal([rows, cols], term_getsize(buf))
+    else
+      let rows = term_getsize(buf)[0]
+*** ../vim-8.1.0833/src/version.c	2019-01-27 15:07:35.161741346 +0100
+--- src/version.c	2019-01-27 16:36:02.924759049 +0100
+***************
+*** 785,786 ****
+--- 785,788 ----
+  {   /* Add new patch number below this line */
++ /**/
++     834,
+  /**/
+
+-- 
+We do not stumble over mountains, but over molehills.
+				Confucius
+
+ /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
+///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
+\\\  an exciting new programming language -- http://www.Zimbu.org        ///
+ \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///