patch 8.2.2961: keys typed during a :normal command are discarded

brammool · brammool · commit c41badb748bb · 2021-06-07T22:04:52.000+02:00
Problem:    Keys typed during a :normal command are discarded.
Solution:   Concatenate saved typeahead and typed kesy. (closes #8340)
diff --git a/src/debugger.c b/src/debugger.c
@@ -140,7 +140,7 @@ do_debug(char_u *cmd)
 
 	if (typeahead_saved)
 	{
-	    restore_typeahead(&typeaheadbuf);
+	    restore_typeahead(&typeaheadbuf, TRUE);
 	    ignore_script = save_ignore_script;
 	}
 	ex_normal_busy = save_ex_normal_busy;
diff --git a/src/evalfunc.c b/src/evalfunc.c
@@ -5873,7 +5873,7 @@ f_inputrestore(typval_T *argvars UNUSED, typval_T *rettv)
     {
 	--ga_userinput.ga_len;
 	restore_typeahead((tasave_T *)(ga_userinput.ga_data)
-						       + ga_userinput.ga_len);
+						  + ga_userinput.ga_len, TRUE);
 	// default return is zero == OK
     }
     else if (p_verbose > 1)
diff --git a/src/ex_docmd.c b/src/ex_docmd.c
@@ -8249,7 +8249,7 @@ save_current_state(save_state_T *sst)
 restore_current_state(save_state_T *sst)
 {
     // Restore the previous typeahead.
-    restore_typeahead(&sst->tabuf);
+    restore_typeahead(&sst->tabuf, FALSE);
 
     msg_scroll = sst->save_msg_scroll;
     restart_edit = sst->save_restart_edit;
diff --git a/src/getchar.c b/src/getchar.c
@@ -1414,9 +1414,10 @@ save_typeahead(tasave_T *tp)
 /*
  * Restore the typeahead to what it was before calling save_typeahead().
  * The allocated memory is freed, can only be called once!
+ * When "overwrite" is FALSE input typed later is kept.
  */
     void
-restore_typeahead(tasave_T *tp)
+restore_typeahead(tasave_T *tp, int overwrite UNUSED)
 {
     if (tp->typebuf_valid)
     {
@@ -1432,7 +1433,7 @@ restore_typeahead(tasave_T *tp)
     free_buff(&readbuf2);
     readbuf2 = tp->save_readbuf2;
 # ifdef USE_INPUT_BUF
-    set_input_buf(tp->save_inputbuf);
+    set_input_buf(tp->save_inputbuf, overwrite);
 # endif
 }
 
diff --git a/src/proto/getchar.pro b/src/proto/getchar.pro
@@ -32,7 +32,7 @@ int typebuf_maplen(void);
 void del_typebuf(int len, int offset);
 int save_typebuf(void);
 void save_typeahead(tasave_T *tp);
-void restore_typeahead(tasave_T *tp);
+void restore_typeahead(tasave_T *tp, int overwrite);
 void openscript(char_u *name, int directly);
 void close_all_scripts(void);
 int using_script(void);
diff --git a/src/proto/ui.pro b/src/proto/ui.pro
@@ -19,7 +19,7 @@ int vim_is_input_buf_empty(void);
 int vim_free_in_input_buf(void);
 int vim_used_in_input_buf(void);
 char_u *get_input_buf(void);
-void set_input_buf(char_u *p);
+void set_input_buf(char_u *p, int overwrite);
 void add_to_input_buf(char_u *s, int len);
 void add_to_input_buf_csi(char_u *str, int len);
 void trash_input_buf(void);
diff --git a/src/ui.c b/src/ui.c
@@ -810,18 +810,28 @@ get_input_buf(void)
 /*
  * Restore the input buffer with a pointer returned from get_input_buf().
  * The allocated memory is freed, this only works once!
+ * When "overwrite" is FALSE input typed later is kept.
  */
     void
-set_input_buf(char_u *p)
+set_input_buf(char_u *p, int overwrite)
 {
     garray_T	*gap = (garray_T *)p;
 
     if (gap != NULL)
     {
 	if (gap->ga_data != NULL)
 	{
-	    mch_memmove(inbuf, gap->ga_data, gap->ga_len);
-	    inbufcount = gap->ga_len;
+	    if (overwrite || inbufcount + gap->ga_len >= INBUFLEN)
+	    {
+		mch_memmove(inbuf, gap->ga_data, gap->ga_len);
+		inbufcount = gap->ga_len;
+	    }
+	    else
+	    {
+		mch_memmove(inbuf + gap->ga_len, inbuf, inbufcount);
+		mch_memmove(inbuf, gap->ga_data, gap->ga_len);
+		inbufcount += gap->ga_len;
+	    }
 	    vim_free(gap->ga_data);
 	}
 	vim_free(gap);
diff --git a/src/version.c b/src/version.c
@@ -750,6 +750,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    2961,
 /**/
     2960,
 /**/

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ do_debug(char_u *cmd)`
`140`	`140`
`141`	`141`	`if (typeahead_saved)`
`142`	`142`	`{`
`143`		`- restore_typeahead(&typeaheadbuf);`
	`143`	`+ restore_typeahead(&typeaheadbuf, TRUE);`
`144`	`144`	`ignore_script = save_ignore_script;`
`145`	`145`	`}`
`146`	`146`	`ex_normal_busy = save_ex_normal_busy;`
Original file line number	Diff line number	Diff line change
`@@ -5873,7 +5873,7 @@ f_inputrestore(typval_T argvars UNUSED, typval_T rettv)`
`5873`	`5873`	`{`
`5874`	`5874`	`--ga_userinput.ga_len;`
`5875`	`5875`	`restore_typeahead((tasave_T *)(ga_userinput.ga_data)`
`5876`		`- + ga_userinput.ga_len);`
	`5876`	`+ + ga_userinput.ga_len, TRUE);`
`5877`	`5877`	`// default return is zero == OK`
`5878`	`5878`	`}`
`5879`	`5879`	`else if (p_verbose > 1)`
Original file line number	Diff line number	Diff line change
`@@ -8249,7 +8249,7 @@ save_current_state(save_state_T *sst)`
`8249`	`8249`	`restore_current_state(save_state_T *sst)`
`8250`	`8250`	`{`
`8251`	`8251`	`// Restore the previous typeahead.`
`8252`		`- restore_typeahead(&sst->tabuf);`
	`8252`	`+ restore_typeahead(&sst->tabuf, FALSE);`
`8253`	`8253`
`8254`	`8254`	`msg_scroll = sst->save_msg_scroll;`
`8255`	`8255`	`restart_edit = sst->save_restart_edit;`
Original file line number	Diff line number	Diff line change
`@@ -1414,9 +1414,10 @@ save_typeahead(tasave_T *tp)`
`1414`	`1414`	`/*`
`1415`	`1415`	`* Restore the typeahead to what it was before calling save_typeahead().`
`1416`	`1416`	`* The allocated memory is freed, can only be called once!`
	`1417`	`+ * When "overwrite" is FALSE input typed later is kept.`
`1417`	`1418`	`*/`
`1418`	`1419`	`void`
`1419`		`-restore_typeahead(tasave_T *tp)`
	`1420`	`+restore_typeahead(tasave_T *tp, int overwrite UNUSED)`
`1420`	`1421`	`{`
`1421`	`1422`	`if (tp->typebuf_valid)`
`1422`	`1423`	`{`
`@@ -1432,7 +1433,7 @@ restore_typeahead(tasave_T *tp)`
`1432`	`1433`	`free_buff(&readbuf2);`
`1433`	`1434`	`readbuf2 = tp->save_readbuf2;`
`1434`	`1435`	`# ifdef USE_INPUT_BUF`
`1435`		`- set_input_buf(tp->save_inputbuf);`
	`1436`	`+ set_input_buf(tp->save_inputbuf, overwrite);`
`1436`	`1437`	`# endif`
`1437`	`1438`	`}`
`1438`	`1439`