To: vim_dev@googlegroups.com

Subject: Patch 7.4.171

Fcc: outbox

From: Bram Moolenaar <Bram@moolenaar.net>

Mime-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

------------

Patch 7.4.171

Problem:    Redo does not set v:count and v:count1.

Solution:   Use a separate buffer for redo, so that we can set the counts when

	    performing redo.

Files:	    src/getchar.c, src/globals.h, src/normal.c, src/proto/getchar.pro,

	    src/structs.h

*** ../vim-7.4.170/src/getchar.c	2013-06-29 13:43:27.000000000 +0200

--- src/getchar.c	2014-02-11 14:54:46.830097259 +0100

***************

*** 40,52 ****

  #define MINIMAL_SIZE 20			/* minimal size for b_str */

! static struct buffheader redobuff = {{NULL, {NUL}}, NULL, 0, 0};

! static struct buffheader old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

  #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)

! static struct buffheader save_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

! static struct buffheader save_old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

  #endif

! static struct buffheader recordbuff = {{NULL, {NUL}}, NULL, 0, 0};

  static int typeahead_char = 0;		/* typeahead char that's not flushed */

--- 40,52 ----

  #define MINIMAL_SIZE 20			/* minimal size for b_str */

! static buffheader_T redobuff = {{NULL, {NUL}}, NULL, 0, 0};

! static buffheader_T old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

  #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)

! static buffheader_T save_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

! static buffheader_T save_old_redobuff = {{NULL, {NUL}}, NULL, 0, 0};

  #endif

! static buffheader_T recordbuff = {{NULL, {NUL}}, NULL, 0, 0};

  static int typeahead_char = 0;		/* typeahead char that's not flushed */

***************

*** 112,122 ****

  static int	last_recorded_len = 0;	/* number of last recorded chars */

! static char_u	*get_buffcont __ARGS((struct buffheader *, int));

! static void	add_buff __ARGS((struct buffheader *, char_u *, long n));

! static void	add_num_buff __ARGS((struct buffheader *, long));

! static void	add_char_buff __ARGS((struct buffheader *, int));

! static int	read_stuff __ARGS((int advance));

  static void	start_stuff __ARGS((void));

  static int	read_redo __ARGS((int, int));

  static void	copy_redo __ARGS((int));

--- 112,123 ----

  static int	last_recorded_len = 0;	/* number of last recorded chars */

! static char_u	*get_buffcont __ARGS((buffheader_T *, int));

! static void	add_buff __ARGS((buffheader_T *, char_u *, long n));

! static void	add_num_buff __ARGS((buffheader_T *, long));

! static void	add_char_buff __ARGS((buffheader_T *, int));

! static int	read_readbuffers __ARGS((int advance));

! static int	read_readbuf __ARGS((buffheader_T *buf, int advance));

  static void	start_stuff __ARGS((void));

  static int	read_redo __ARGS((int, int));

  static void	copy_redo __ARGS((int));

***************

*** 137,145 ****

   */

      void

  free_buff(buf)

!     struct buffheader	*buf;

  {

!     struct buffblock	*p, *np;

      for (p = buf->bh_first.b_next; p != NULL; p = np)

      {

--- 138,146 ----

   */

      void

  free_buff(buf)

!     buffheader_T	*buf;

  {

!     buffblock_T	*p, *np;

      for (p = buf->bh_first.b_next; p != NULL; p = np)

      {

***************

*** 155,168 ****

   */

      static char_u *

  get_buffcont(buffer, dozero)

!     struct buffheader	*buffer;

      int			dozero;	    /* count == zero is not an error */

  {

      long_u	    count = 0;

      char_u	    *p = NULL;

      char_u	    *p2;

      char_u	    *str;

!     struct buffblock *bp;

      /* compute the total length of the string */

      for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next)

--- 156,169 ----

   */

      static char_u *

  get_buffcont(buffer, dozero)

!     buffheader_T	*buffer;

      int			dozero;	    /* count == zero is not an error */

  {

      long_u	    count = 0;

      char_u	    *p = NULL;

      char_u	    *p2;

      char_u	    *str;

!     buffblock_T *bp;

      /* compute the total length of the string */

      for (bp = buffer->bh_first.b_next; bp != NULL; bp = bp->b_next)

***************

*** 230,240 ****

   */

      static void

  add_buff(buf, s, slen)

!     struct buffheader	*buf;

      char_u		*s;

      long		slen;	/* length of "s" or -1 */

  {

!     struct buffblock *p;

      long_u	    len;

      if (slen < 0)

--- 231,241 ----

   */

      static void

  add_buff(buf, s, slen)

!     buffheader_T	*buf;

      char_u		*s;

      long		slen;	/* length of "s" or -1 */

  {

!     buffblock_T *p;

      long_u	    len;

      if (slen < 0)

***************

*** 270,276 ****

  	    len = MINIMAL_SIZE;

  	else

  	    len = slen;

! 	p = (struct buffblock *)lalloc((long_u)(sizeof(struct buffblock) + len),

  									TRUE);

  	if (p == NULL)

  	    return; /* no space, just forget it */

--- 271,277 ----

  	    len = MINIMAL_SIZE;

  	else

  	    len = slen;

! 	p = (buffblock_T *)lalloc((long_u)(sizeof(buffblock_T) + len),

  									TRUE);

  	if (p == NULL)

  	    return; /* no space, just forget it */

***************

*** 289,295 ****

   */

      static void

  add_num_buff(buf, n)

!     struct buffheader *buf;

      long	      n;

  {

      char_u	number[32];

--- 290,296 ----

   */

      static void

  add_num_buff(buf, n)

!     buffheader_T *buf;

      long	      n;

  {

      char_u	number[32];

***************

*** 304,310 ****

   */

      static void

  add_char_buff(buf, c)

!     struct buffheader	*buf;

      int			c;

  {

  #ifdef FEAT_MBYTE

--- 305,311 ----

   */

      static void

  add_char_buff(buf, c)

!     buffheader_T	*buf;

      int			c;

  {

  #ifdef FEAT_MBYTE

***************

*** 354,399 ****

  #endif

  }

  /*

!  * Get one byte from the stuff buffer.

   * If advance == TRUE go to the next char.

   * No translation is done K_SPECIAL and CSI are escaped.

   */

      static int

! read_stuff(advance)

      int		advance;

  {

!     char_u		c;

!     struct buffblock	*curr;

!     if (stuffbuff.bh_first.b_next == NULL)  /* buffer is empty */

  	return NUL;

!     curr = stuffbuff.bh_first.b_next;

!     c = curr->b_str[stuffbuff.bh_index];

      if (advance)

      {

! 	if (curr->b_str[++stuffbuff.bh_index] == NUL)

  	{

! 	    stuffbuff.bh_first.b_next = curr->b_next;

  	    vim_free(curr);

! 	    stuffbuff.bh_index = 0;

  	}

      }

      return c;

  }

  /*

!  * Prepare the stuff buffer for reading (if it contains something).

   */

      static void

  start_stuff()

  {

!     if (stuffbuff.bh_first.b_next != NULL)

      {

! 	stuffbuff.bh_curr = &(stuffbuff.bh_first);

! 	stuffbuff.bh_space = 0;

      }

  }

--- 355,425 ----

  #endif

  }

+ /* First read ahead buffer. Used for translated commands. */

+ static buffheader_T readbuf1 = {{NULL, {NUL}}, NULL, 0, 0};

+ 

+ /* Second read ahead buffer. Used for redo. */

+ static buffheader_T readbuf2 = {{NULL, {NUL}}, NULL, 0, 0};

+ 

  /*

!  * Get one byte from the read buffers.  Use readbuf1 one first, use readbuf2

!  * if that one is empty.

   * If advance == TRUE go to the next char.

   * No translation is done K_SPECIAL and CSI are escaped.

   */

      static int

! read_readbuffers(advance)

      int		advance;

  {

!     int c;

! 

!     c = read_readbuf(&readbuf1, advance);

!     if (c == NUL)

! 	c = read_readbuf(&readbuf2, advance);

!     return c;

! }

! 

!     static int

! read_readbuf(buf, advance)

!     buffheader_T    *buf;

!     int		    advance;

! {

!     char_u	c;

!     buffblock_T	*curr;

!     if (buf->bh_first.b_next == NULL)  /* buffer is empty */

  	return NUL;

!     curr = buf->bh_first.b_next;

!     c = curr->b_str[buf->bh_index];

      if (advance)

      {

! 	if (curr->b_str[++buf->bh_index] == NUL)

  	{

! 	    buf->bh_first.b_next = curr->b_next;

  	    vim_free(curr);

! 	    buf->bh_index = 0;

  	}

      }

      return c;

  }

  /*

!  * Prepare the read buffers for reading (if they contains something).

   */

      static void

  start_stuff()

  {

!     if (readbuf1.bh_first.b_next != NULL)

      {

! 	readbuf1.bh_curr = &(readbuf1.bh_first);

! 	readbuf1.bh_space = 0;

!     }

!     if (readbuf2.bh_first.b_next != NULL)

!     {

! 	readbuf2.bh_curr = &(readbuf2.bh_first);

! 	readbuf2.bh_space = 0;

      }

  }

***************

*** 403,409 ****

      int

  stuff_empty()

  {

!     return (stuffbuff.bh_first.b_next == NULL);

  }

  /*

--- 429,446 ----

      int

  stuff_empty()

  {

!     return (readbuf1.bh_first.b_next == NULL

! 	 && readbuf2.bh_first.b_next == NULL);

! }

! 

! /*

!  * Return TRUE if readbuf1 is empty.  There may still be redo characters in

!  * redbuf2.

!  */

!     int

! readbuf1_empty()

! {

!     return (readbuf1.bh_first.b_next == NULL);

  }

  /*

***************

*** 428,434 ****

      init_typebuf();

      start_stuff();

!     while (read_stuff(TRUE) != NUL)

  	;

      if (flush_typeahead)	    /* remove all typeahead */

--- 465,471 ----

      init_typebuf();

      start_stuff();

!     while (read_readbuffers(TRUE) != NUL)

  	;

      if (flush_typeahead)	    /* remove all typeahead */

***************

*** 483,489 ****

  	redobuff = old_redobuff;

  	old_redobuff.bh_first.b_next = NULL;

  	start_stuff();

! 	while (read_stuff(TRUE) != NUL)

  	    ;

      }

  }

--- 520,526 ----

  	redobuff = old_redobuff;

  	old_redobuff.bh_first.b_next = NULL;

  	start_stuff();

! 	while (read_readbuffers(TRUE) != NUL)

  	    ;

      }

  }

***************

*** 638,644 ****

  stuffReadbuff(s)

      char_u	*s;

  {

!     add_buff(&stuffbuff, s, -1L);

  }

      void

--- 675,681 ----

  stuffReadbuff(s)

      char_u	*s;

  {

!     add_buff(&readbuf1, s, -1L);

  }

      void

***************

*** 646,652 ****

      char_u	*s;

      long	len;

  {

!     add_buff(&stuffbuff, s, len);

  }

  #if defined(FEAT_EVAL) || defined(PROTO)

--- 683,689 ----

      char_u	*s;

      long	len;

  {

!     add_buff(&readbuf1, s, len);

  }

  #if defined(FEAT_EVAL) || defined(PROTO)

***************

*** 692,698 ****

  stuffcharReadbuff(c)

      int		   c;

  {

!     add_char_buff(&stuffbuff, c);

  }

  /*

--- 729,735 ----

  stuffcharReadbuff(c)

      int		   c;

  {

!     add_char_buff(&readbuf1, c);

  }

  /*

***************

*** 702,708 ****

  stuffnumReadbuff(n)

      long    n;

  {

!     add_num_buff(&stuffbuff, n);

  }

  /*

--- 739,745 ----

  stuffnumReadbuff(n)

      long    n;

  {

!     add_num_buff(&readbuf1, n);

  }

  /*

***************

*** 718,730 ****

      int		init;

      int		old_redo;

  {

!     static struct buffblock	*bp;

!     static char_u		*p;

!     int				c;

  #ifdef FEAT_MBYTE

!     int				n;

!     char_u			buf[MB_MAXBYTES + 1];

!     int				i;

  #endif

      if (init)

--- 755,767 ----

      int		init;

      int		old_redo;

  {

!     static buffblock_T	*bp;

!     static char_u	*p;

!     int			c;

  #ifdef FEAT_MBYTE

!     int			n;

!     char_u		buf[MB_MAXBYTES + 1];

!     int			i;

  #endif

      if (init)

***************

*** 795,805 ****

      int	    c;

      while ((c = read_redo(FALSE, old_redo)) != NUL)

! 	stuffcharReadbuff(c);

  }

  /*

!  * Stuff the redo buffer into the stuffbuff.

   * Insert the redo count into the command.

   * If "old_redo" is TRUE, the last but one command is repeated

   * instead of the last command (inserting text). This is used for

--- 832,842 ----

      int	    c;

      while ((c = read_redo(FALSE, old_redo)) != NUL)

! 	add_char_buff(&readbuf2, c);

  }

  /*

!  * Stuff the redo buffer into readbuf2.

   * Insert the redo count into the command.

   * If "old_redo" is TRUE, the last but one command is repeated

   * instead of the last command (inserting text). This is used for

***************

*** 823,835 ****

      /* copy the buffer name, if present */

      if (c == '"')

      {

! 	add_buff(&stuffbuff, (char_u *)"\"", 1L);

  	c = read_redo(FALSE, old_redo);

  	/* if a numbered buffer is used, increment the number */

  	if (c >= '1' && c < '9')

  	    ++c;

! 	add_char_buff(&stuffbuff, c);

  	c = read_redo(FALSE, old_redo);

      }

--- 860,872 ----

      /* copy the buffer name, if present */

      if (c == '"')

      {

! 	add_buff(&readbuf2, (char_u *)"\"", 1L);

  	c = read_redo(FALSE, old_redo);

  	/* if a numbered buffer is used, increment the number */

  	if (c >= '1' && c < '9')

  	    ++c;

! 	add_char_buff(&readbuf2, c);

  	c = read_redo(FALSE, old_redo);

      }

***************

*** 850,867 ****

      {

  	while (VIM_ISDIGIT(c))	/* skip "old" count */

  	    c = read_redo(FALSE, old_redo);

! 	add_num_buff(&stuffbuff, count);

      }

      /* copy from the redo buffer into the stuff buffer */

!     add_char_buff(&stuffbuff, c);

      copy_redo(old_redo);

      return OK;

  }

  /*

   * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing

!  * the redo buffer into the stuffbuff.

   * return FAIL for failure, OK otherwise

   */

      int

--- 887,904 ----

      {

  	while (VIM_ISDIGIT(c))	/* skip "old" count */

  	    c = read_redo(FALSE, old_redo);

! 	add_num_buff(&readbuf2, count);

      }

      /* copy from the redo buffer into the stuff buffer */

!     add_char_buff(&readbuf2, c);

      copy_redo(old_redo);

      return OK;

  }

  /*

   * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing

!  * the redo buffer into readbuf2.

   * return FAIL for failure, OK otherwise

   */

      int

***************

*** 879,885 ****

  	if (vim_strchr((char_u *)"AaIiRrOo", c) != NULL)

  	{

  	    if (c == 'O' || c == 'o')

! 		stuffReadbuff(NL_STR);

  	    break;

  	}

      }

--- 916,922 ----

  	if (vim_strchr((char_u *)"AaIiRrOo", c) != NULL)

  	{

  	    if (c == 'O' || c == 'o')

! 		add_buff(&readbuf2, NL_STR, -1L);

  	    break;

  	}

      }

***************

*** 1360,1367 ****

      tp->old_mod_mask = old_mod_mask;

      old_char = -1;

!     tp->save_stuffbuff = stuffbuff;

!     stuffbuff.bh_first.b_next = NULL;

  # ifdef USE_INPUT_BUF

      tp->save_inputbuf = get_input_buf();

  # endif

--- 1397,1406 ----

      tp->old_mod_mask = old_mod_mask;

      old_char = -1;

!     tp->save_readbuf1 = readbuf1;

!     readbuf1.bh_first.b_next = NULL;

!     tp->save_readbuf2 = readbuf2;

!     readbuf2.bh_first.b_next = NULL;

  # ifdef USE_INPUT_BUF

      tp->save_inputbuf = get_input_buf();

  # endif

***************

*** 1384,1391 ****

      old_char = tp->old_char;

      old_mod_mask = tp->old_mod_mask;

!     free_buff(&stuffbuff);

!     stuffbuff = tp->save_stuffbuff;

  # ifdef USE_INPUT_BUF

      set_input_buf(tp->save_inputbuf);

  # endif

--- 1423,1432 ----

      old_char = tp->old_char;

      old_mod_mask = tp->old_mod_mask;

!     free_buff(&readbuf1);

!     readbuf1 = tp->save_readbuf1;

!     free_buff(&readbuf2);

!     readbuf2 = tp->save_readbuf2;

  # ifdef USE_INPUT_BUF

      set_input_buf(tp->save_inputbuf);

  # endif

***************

*** 1992,1998 ****

  		typeahead_char = 0;

  	}

  	else

! 	    c = read_stuff(advance);

  	if (c != NUL && !got_int)

  	{

  	    if (advance)

--- 2033,2039 ----

  		typeahead_char = 0;

  	}

  	else

! 	    c = read_readbuffers(advance);

  	if (c != NUL && !got_int)

  	{

  	    if (advance)

*** ../vim-7.4.170/src/globals.h	2013-11-09 03:31:45.000000000 +0100

--- src/globals.h	2014-02-11 14:17:44.070063200 +0100

***************

*** 979,989 ****

  EXTERN int	readonlymode INIT(= FALSE); /* Set to TRUE for "view" */

  EXTERN int	recoverymode INIT(= FALSE); /* Set to TRUE for "-r" option */

- EXTERN struct buffheader stuffbuff	/* stuff buffer */

- #ifdef DO_INIT

- 		    = {{NULL, {NUL}}, NULL, 0, 0}

- #endif

- 		    ;

  EXTERN typebuf_T typebuf		/* typeahead buffer */

  #ifdef DO_INIT

  		    = {NULL, NULL, 0, 0, 0, 0, 0, 0, 0}

--- 979,984 ----

*** ../vim-7.4.170/src/normal.c	2014-01-14 13:18:53.000000000 +0100

--- src/normal.c	2014-02-11 14:53:54.246096453 +0100

***************

*** 655,662 ****

  #ifdef FEAT_EVAL

      /* Set v:count here, when called from main() and not a stuffed

       * command, so that v:count can be used in an expression mapping

!      * when there is no count. */

!     if (toplevel && stuff_empty())

  	set_vcount_ca(&ca, &set_prevcount);

  #endif

--- 655,662 ----

  #ifdef FEAT_EVAL

      /* Set v:count here, when called from main() and not a stuffed

       * command, so that v:count can be used in an expression mapping

!      * when there is no count. Do set it for redo. */

!     if (toplevel && readbuf1_empty())

  	set_vcount_ca(&ca, &set_prevcount);

  #endif

***************

*** 736,743 ****

  #ifdef FEAT_EVAL

  	    /* Set v:count here, when called from main() and not a stuffed

  	     * command, so that v:count can be used in an expression mapping

! 	     * right after the count. */

! 	    if (toplevel && stuff_empty())

  		set_vcount_ca(&ca, &set_prevcount);

  #endif

  	    if (ctrl_w)

--- 736,743 ----

  #ifdef FEAT_EVAL

  	    /* Set v:count here, when called from main() and not a stuffed

  	     * command, so that v:count can be used in an expression mapping

! 	     * right after the count. Do set it for redo. */

! 	    if (toplevel && readbuf1_empty())

  		set_vcount_ca(&ca, &set_prevcount);

  #endif

  	    if (ctrl_w)

***************

*** 819,826 ****

  #ifdef FEAT_EVAL

      /*

       * Only set v:count when called from main() and not a stuffed command.

       */

!     if (toplevel && stuff_empty())

  	set_vcount(ca.count0, ca.count1, set_prevcount);

  #endif

--- 819,827 ----

  #ifdef FEAT_EVAL

      /*