Merge remote-tracking branch 'upstream/master' into userreguserreg

1 files changed, 323 insertions, 341 deletions

diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 58a18ca5a8..1f789dc153 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -1,6 +1,3 @@
-// This is an open source non-commercial project. Dear PVS-Studio, please check
-// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
 //
 // normal.c:    Contains the main routine for processing characters in command
 //              mode.  Communicates closely with the code in ops.c to handle
@@ -17,9 +14,8 @@
 #include <string.h>
 #include <time.h>
 
-#include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/ascii.h"
+#include "nvim/ascii_defs.h"
 #include "nvim/autocmd.h"
 #include "nvim/buffer.h"
 #include "nvim/buffer_defs.h"
@@ -38,14 +34,15 @@
 #include "nvim/ex_getln.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
+#include "nvim/func_attr.h"
 #include "nvim/getchar.h"
 #include "nvim/gettext.h"
 #include "nvim/globals.h"
 #include "nvim/grid.h"
 #include "nvim/help.h"
-#include "nvim/highlight_defs.h"
+#include "nvim/highlight.h"
 #include "nvim/keycodes.h"
-#include "nvim/macros.h"
+#include "nvim/macros_defs.h"
 #include "nvim/mapping.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
@@ -57,12 +54,12 @@
 #include "nvim/normal.h"
 #include "nvim/ops.h"
 #include "nvim/option.h"
+#include "nvim/option_vars.h"
 #include "nvim/os/input.h"
 #include "nvim/os/time.h"
 #include "nvim/plines.h"
 #include "nvim/profile.h"
 #include "nvim/quickfix.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/spell.h"
 #include "nvim/spellfile.h"
@@ -74,10 +71,9 @@
 #include "nvim/tag.h"
 #include "nvim/textformat.h"
 #include "nvim/textobject.h"
-#include "nvim/types.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
-#include "nvim/vim.h"
+#include "nvim/vim_defs.h"
 #include "nvim/window.h"
 
 typedef struct normal_state {
@@ -107,6 +103,10 @@ static int VIsual_mode_orig = NUL;              // saved Visual mode
 # include "normal.c.generated.h"
 #endif
 
+static const char e_changelist_is_empty[] = N_("E664: Changelist is empty");
+static const char e_cmdline_window_already_open[]
+  = N_("E1292: Command-line window is already open");
+
 static inline void normal_state_init(NormalState *s)
 {
   memset(s, 0, sizeof(NormalState));
@@ -118,7 +118,7 @@ static inline void normal_state_init(NormalState *s)
 // n_*(): functions called to handle Normal mode commands.
 // v_*(): functions called to handle Visual mode commands.
 
-static char *e_noident = N_("E349: No identifier under cursor");
+static const char *e_noident = N_("E349: No identifier under cursor");
 
 /// Function to be called for a Normal or Visual mode command.
 /// The argument is a cmdarg_T.
@@ -359,11 +359,9 @@ static int nv_max_linear;
 /// through the index in nv_cmd_idx[].
 static int nv_compare(const void *s1, const void *s2)
 {
-  int c1, c2;
-
   // The commands are sorted on absolute value.
-  c1 = nv_cmds[*(const int16_t *)s1].cmd_char;
-  c2 = nv_cmds[*(const int16_t *)s2].cmd_char;
+  int c1 = nv_cmds[*(const int16_t *)s1].cmd_char;
+  int c2 = nv_cmds[*(const int16_t *)s2].cmd_char;
   if (c1 < 0) {
     c1 = -c1;
   }
@@ -401,11 +399,6 @@ void init_normal_cmds(void)
 /// @return  -1 for invalid command.
 static int find_command(int cmdchar)
 {
-  int i;
-  int idx;
-  int top, bot;
-  int c;
-
   // A multi-byte character is never a command.
   if (cmdchar >= 0x100) {
     return -1;
@@ -425,12 +418,12 @@ static int find_command(int cmdchar)
   }
 
   // Perform a binary search.
-  bot = nv_max_linear + 1;
-  top = NV_CMDS_SIZE - 1;
-  idx = -1;
+  int bot = nv_max_linear + 1;
+  int top = NV_CMDS_SIZE - 1;
+  int idx = -1;
   while (bot <= top) {
-    i = (top + bot) / 2;
-    c = nv_cmds[nv_cmd_idx[i]].cmd_char;
+    int i = (top + bot) / 2;
+    int c = nv_cmds[nv_cmd_idx[i]].cmd_char;
     if (c < 0) {
       c = -c;
     }
@@ -465,7 +458,7 @@ static bool check_text_locked(oparg_T *oap)
 /// If text is locked, "curbuf->b_ro_locked" or "allbuf_lock" is set:
 /// Give an error message, possibly beep and return true.
 /// "oap" may be NULL.
-static bool check_text_or_curbuf_locked(oparg_T *oap)
+bool check_text_or_curbuf_locked(oparg_T *oap)
 {
   if (check_text_locked(oap)) {
     return true;
@@ -481,6 +474,20 @@ static bool check_text_or_curbuf_locked(oparg_T *oap)
   return true;
 }
 
+static oparg_T *current_oap = NULL;
+
+/// Check if an operator was started but not finished yet.
+/// Includes typing a count or a register name.
+bool op_pending(void)
+{
+  return !(current_oap != NULL
+           && !finish_op
+           && current_oap->prev_opcount == 0
+           && current_oap->prev_count0 == 0
+           && current_oap->op_type == OP_NOP
+           && current_oap->regname == NUL);
+}
+
 /// Normal state entry point. This is called on:
 ///
 /// - Startup, In this case the function never returns.
@@ -489,15 +496,18 @@ static bool check_text_or_curbuf_locked(oparg_T *oap)
 ///   for example. Returns when re-entering ex mode(because ex mode recursion is
 ///   not allowed)
 ///
-/// This used to be called main_loop on main.c
+/// This used to be called main_loop() on main.c
 void normal_enter(bool cmdwin, bool noexmode)
 {
   NormalState state;
   normal_state_init(&state);
+  oparg_T *prev_oap = current_oap;
+  current_oap = &state.oa;
   state.cmdwin = cmdwin;
   state.noexmode = noexmode;
   state.toplevel = (!cmdwin || cmdwin_result == 0) && !noexmode;
   state_enter(&state.state);
+  current_oap = prev_oap;
 }
 
 static void normal_prepare(NormalState *s)
@@ -671,16 +681,16 @@ static void normal_redraw_mode_message(NormalState *s)
     keep_msg = kmsg;
 
     kmsg = xstrdup(keep_msg);
-    msg_attr((const char *)kmsg, keep_msg_attr);
+    msg(kmsg, keep_msg_attr);
     xfree(kmsg);
   }
   setcursor();
   ui_cursor_shape();                  // show different cursor shape
   ui_flush();
   if (msg_scroll || emsg_on_display) {
-    os_delay(1003L, true);            // wait at least one second
+    os_delay(1003, true);            // wait at least one second
   }
-  os_delay(3003L, false);             // wait up to three seconds
+  os_delay(3003, false);             // wait up to three seconds
   State = save_State;
 
   msg_scroll = false;
@@ -693,7 +703,6 @@ static void normal_get_additional_char(NormalState *s)
   int *cp;
   bool repl = false;            // get character for replace mode
   bool lit = false;             // get extra character literally
-  bool langmap_active = false;  // using :lmap mappings
   int lang;                     // getting a text character
 
   no_mapping++;
@@ -729,6 +738,7 @@ static void normal_get_additional_char(NormalState *s)
 
   // Get a second or third character.
   if (cp != NULL) {
+    bool langmap_active = false;  // using :lmap mappings
     if (repl) {
       State = MODE_REPLACE;                // pretend Replace mode
       ui_cursor_shape();              // show different cursor shape
@@ -771,10 +781,6 @@ static void normal_get_additional_char(NormalState *s)
 
       // adjust chars > 127, except after "tTfFr" commands
       LANGMAP_ADJUST(*cp, !lang);
-      // adjust Hebrew mapped char
-      if (p_hkmap && lang && KeyTyped) {
-        *cp = hkmap(*cp);
-      }
     }
 
     // When the next character is CTRL-\ a following CTRL-N means the
@@ -789,13 +795,13 @@ static void normal_get_additional_char(NormalState *s)
                && s->ca.cmdchar == 'g') {
       s->ca.oap->op_type = get_op_type(*cp, NUL);
     } else if (*cp == Ctrl_BSL) {
-      long towait = (p_ttm >= 0 ? p_ttm : p_tm);
+      int towait = (p_ttm >= 0 ? (int)p_ttm : (int)p_tm);
 
       // There is a busy wait here when typing "f<C-\>" and then
       // something different from CTRL-N.  Can't be avoided.
-      while ((s->c = vpeekc()) <= 0 && towait > 0L) {
-        do_sleep(towait > 50L ? 50L : towait);
-        towait -= 50L;
+      while ((s->c = vpeekc()) <= 0 && towait > 0) {
+        do_sleep(towait > 50 ? 50 : towait);
+        towait -= 50;
       }
       if (s->c > 0) {
         s->c = plain_vgetc();
@@ -810,25 +816,34 @@ static void normal_get_additional_char(NormalState *s)
       }
     }
 
-    // When getting a text character and the next character is a
-    // multi-byte character, it could be a composing character.
-    // However, don't wait for it to arrive. Also, do enable mapping,
-    // because if it's put back with vungetc() it's too late to apply
-    // mapping.
-    no_mapping--;
-    while (lang && (s->c = vpeekc()) > 0
-           && (s->c >= 0x100 || MB_BYTE2LEN(vpeekc()) > 1)) {
-      s->c = plain_vgetc();
-      if (!utf_iscomposing(s->c)) {
-        vungetc(s->c);                   // it wasn't, put it back
-        break;
-      } else if (s->ca.ncharC1 == 0) {
-        s->ca.ncharC1 = s->c;
-      } else {
-        s->ca.ncharC2 = s->c;
+    if (lang) {
+      // When getting a text character and the next character is a
+      // multi-byte character, it could be a composing character.
+      // However, don't wait for it to arrive. Also, do enable mapping,
+      // because if it's put back with vungetc() it's too late to apply
+      // mapping.
+      no_mapping--;
+      while ((s->c = vpeekc()) > 0
+             && (s->c >= 0x100 || MB_BYTE2LEN(vpeekc()) > 1)) {
+        s->c = plain_vgetc();
+        if (!utf_iscomposing(s->c)) {
+          vungetc(s->c);                   // it wasn't, put it back
+          break;
+        } else if (s->ca.ncharC1 == 0) {
+          s->ca.ncharC1 = s->c;
+        } else {
+          s->ca.ncharC2 = s->c;
+        }
       }
+      no_mapping++;
+      // Vim may be in a different mode when the user types the next key,
+      // but when replaying a recording the next key is already in the
+      // typeahead buffer, so record a <Nop> before that to prevent the
+      // vpeekc() above from applying wrong mappings when replaying.
+      no_u_sync++;
+      gotchars_nop();
+      no_u_sync--;
     }
-    no_mapping++;
   }
   no_mapping--;
   allow_keys--;
@@ -874,8 +889,8 @@ static bool normal_get_command_count(NormalState *s)
     if (s->c == K_DEL || s->c == K_KDEL) {
       s->ca.count0 /= 10;
       del_from_showcmd(4);            // delete the digit and ~@%
-    } else if (s->ca.count0 > 99999999L) {
-      s->ca.count0 = 999999999L;
+    } else if (s->ca.count0 > 99999999) {
+      s->ca.count0 = 999999999;
     } else {
       s->ca.count0 = s->ca.count0 * 10 + (s->c - '0');
     }
@@ -963,13 +978,16 @@ normal_end:
     set_reg_var(get_default_register_name());
   }
 
-  // Reset finish_op, in case it was set
-  s->c = finish_op;
-  finish_op = false;
-  may_trigger_modechanged();
+  const bool prev_finish_op = finish_op;
+  if (s->oa.op_type == OP_NOP) {
+    // Reset finish_op, in case it was set
+    finish_op = false;
+    may_trigger_modechanged();
+  }
   // Redraw the cursor with another shape, if we were in Operator-pending
   // mode or did a replace command.
-  if (s->c || s->ca.cmdchar == 'r') {
+  if (prev_finish_op || s->ca.cmdchar == 'r'
+      || (s->ca.cmdchar == 'g' && s->ca.nchar == 'r')) {
     ui_cursor_shape();                  // may show different cursor shape
   }
 
@@ -1010,7 +1028,7 @@ normal_end:
       restart_VIsual_select = 0;
     }
     if (restart_edit != 0 && !VIsual_active && s->old_mapped_len == 0) {
-      (void)edit(restart_edit, false, 1L);
+      (void)edit(restart_edit, false, 1);
     }
   }
 
@@ -1088,8 +1106,8 @@ static int normal_execute(VimState *state, int key)
     // If you give a count before AND after the operator, they are
     // multiplied.
     if (s->ca.count0) {
-      if (s->ca.opcount >= 999999999L / s->ca.count0) {
-        s->ca.count0 = 999999999L;
+      if (s->ca.opcount >= 999999999 / s->ca.count0) {
+        s->ca.count0 = 999999999;
       } else {
         s->ca.count0 *= s->ca.opcount;
       }
@@ -1168,7 +1186,7 @@ static int normal_execute(VimState *state, int key)
 
   State = MODE_NORMAL;
 
-  if (s->ca.nchar == ESC) {
+  if (s->ca.nchar == ESC || s->ca.extra_char == ESC) {
     clearop(&s->oa);
     s->command_finished = true;
     goto finish;
@@ -1179,7 +1197,7 @@ static int normal_execute(VimState *state, int key)
     msg_col = 0;
   }
 
-  s->old_pos = curwin->w_cursor;           // remember where cursor was
+  s->old_pos = curwin->w_cursor;           // remember where the cursor was
 
   // When 'keymodel' contains "startsel" some keys start Select/Visual
   // mode.
@@ -1260,9 +1278,11 @@ static void normal_check_cursor_moved(NormalState *s)
 {
   // Trigger CursorMoved if the cursor moved.
   if (!finish_op && has_event(EVENT_CURSORMOVED)
-      && !equalpos(curwin->w_last_cursormoved, curwin->w_cursor)) {
+      && (last_cursormoved_win != curwin
+          || !equalpos(last_cursormoved, curwin->w_cursor))) {
     apply_autocmds(EVENT_CURSORMOVED, NULL, NULL, false, curbuf);
-    curwin->w_last_cursormoved = curwin->w_cursor;
+    last_cursormoved_win = curwin;
+    last_cursormoved = curwin->w_cursor;
   }
 }
 
@@ -1286,6 +1306,13 @@ static void normal_check_buffer_modified(NormalState *s)
   }
 }
 
+/// If nothing is pending and we are going to wait for the user to
+/// type a character, trigger SafeState.
+static void normal_check_safe_state(NormalState *s)
+{
+  may_trigger_safestate(!op_pending() && restart_edit == 0);
+}
+
 static void normal_check_folds(NormalState *s)
 {
   // Include a closed fold completely in the Visual area.
@@ -1311,16 +1338,20 @@ static void normal_redraw(NormalState *s)
   update_topline(curwin);
   validate_cursor();
 
+  show_cursor_info_later(false);
+
   if (VIsual_active) {
     redraw_curbuf_later(UPD_INVERTED);  // update inverted part
-    update_screen();
-  } else if (must_redraw) {
-    update_screen();
-  } else if (redraw_cmdline || clear_cmdline || redraw_mode) {
-    showmode();
   }
 
-  redraw_statuslines();
+  if (must_redraw) {
+    update_screen();
+  } else {
+    redraw_statuslines();
+    if (redraw_cmdline || clear_cmdline || redraw_mode) {
+      showmode();
+    }
+  }
 
   if (need_maketitle) {
     maketitle();
@@ -1338,7 +1369,7 @@ static void normal_redraw(NormalState *s)
     // check for duplicates.  Never put this message in
     // history.
     msg_hist_off = true;
-    msg_attr((const char *)p, keep_msg_attr);
+    msg(p, keep_msg_attr);
     msg_hist_off = false;
     xfree(p);
   }
@@ -1353,7 +1384,6 @@ static void normal_redraw(NormalState *s)
   did_emsg = false;
   msg_didany = false;  // reset lines_left in msg_start()
   may_clear_sb_text();  // clear scroll-back text on next msg
-  show_cursor_info(false);
 
   setcursor();
 }
@@ -1375,11 +1405,14 @@ static int normal_check(VimState *state)
   }
   quit_more = false;
 
+  state_no_longer_safe(NULL);
+
   // If skip redraw is set (for ":" in wait_return()), don't redraw now.
   // If there is nothing in the stuff_buffer or do_redraw is true,
   // update cursor and redraw.
   if (skip_redraw || exmode_active) {
     skip_redraw = false;
+    setcursor();
   } else if (do_redraw || stuff_empty()) {
     // Ensure curwin->w_topline and curwin->w_leftcol are up to date
     // before triggering a WinScrolled autocommand.
@@ -1390,6 +1423,7 @@ static int normal_check(VimState *state)
     normal_check_text_changed(s);
     normal_check_window_scrolled(s);
     normal_check_buffer_modified(s);
+    normal_check_safe_state(s);
 
     // Updating diffs from changed() does not always work properly,
     // esp. updating folds.  Do an update just before redrawing if
@@ -1402,7 +1436,7 @@ static int normal_check(VimState *state)
     // Scroll-binding for diff mode may have been postponed until
     // here.  Avoids doing it for every change.
     if (diff_need_scrollbind) {
-      check_scrollbind((linenr_T)0, 0L);
+      check_scrollbind(0, 0);
       diff_need_scrollbind = false;
     }
 
@@ -1455,7 +1489,7 @@ static int normal_check(VimState *state)
 /// Set v:prevcount only when "set_prevcount" is true.
 static void set_vcount_ca(cmdarg_T *cap, bool *set_prevcount)
 {
-  long count = cap->count0;
+  int64_t count = cap->count0;
 
   // multiply with cap->opcount the same way as above
   if (cap->opcount != 0) {
@@ -1597,7 +1631,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
 
   // if i == 0: try to find an identifier
   // if i == 1: try to find any non-white text
-  char *ptr = ml_get_buf(wp->w_buffer, lnum, false);
+  char *ptr = ml_get_buf(wp->w_buffer, lnum);
   for (i = (find_type & FIND_IDENT) ? 0 : 1; i < 2; i++) {
     // 1. skip to start of identifier/text
     col = startcol;
@@ -1671,7 +1705,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
   col = 0;
   // Search for point of changing multibyte character class.
   this_class = mb_get_class(ptr);
-  while (ptr[col] != NUL  // -V781
+  while (ptr[col] != NUL
          && ((i == 0
               ? mb_get_class(ptr + col) == this_class
               : mb_get_class(ptr + col) != 0)
@@ -1694,13 +1728,13 @@ static void prep_redo_cmd(cmdarg_T *cap)
 
 /// Prepare for redo of any command.
 /// Note that only the last argument can be a multi-byte char.
-void prep_redo(int regname, long num, int cmd1, int cmd2, int cmd3, int cmd4, int cmd5)
+void prep_redo(int regname, int num, int cmd1, int cmd2, int cmd3, int cmd4, int cmd5)
 {
-  prep_redo_num2(regname, num, cmd1, cmd2, 0L, cmd3, cmd4, cmd5);
+  prep_redo_num2(regname, num, cmd1, cmd2, 0, cmd3, cmd4, cmd5);
 }
 
 /// Prepare for redo of any command with extra count after "cmd2".
-void prep_redo_num2(int regname, long num1, int cmd1, int cmd2, long num2, int cmd3, int cmd4,
+void prep_redo_num2(int regname, int num1, int cmd1, int cmd2, int num2, int cmd3, int cmd4,
                     int cmd5)
 {
   ResetRedobuff();
@@ -1731,9 +1765,9 @@ void prep_redo_num2(int regname, long num1, int cmd1, int cmd2, long num2, int c
   }
 }
 
-/// check for operator active and clear it
+/// Check for operator active and clear it.
 ///
-/// @return  true if operator was active
+/// Beep and return true if an operator was active.
 static bool checkclearop(oparg_T *oap)
 {
   if (oap->op_type == OP_NOP) {
@@ -1745,7 +1779,7 @@ static bool checkclearop(oparg_T *oap)
 
 /// Check for operator or Visual active.  Clear active operator.
 ///
-/// @return  true if operator or Visual was active.
+/// Beep and return true if an operator or Visual was active.
 static bool checkclearopq(oparg_T *oap)
 {
   if (oap->op_type == OP_NOP && !VIsual_active) {
@@ -1815,7 +1849,7 @@ void clear_showcmd(void)
 
   if (VIsual_active && !char_avail()) {
     int cursor_bot = lt(VIsual, curwin->w_cursor);
-    long lines;
+    int lines;
     colnr_T leftcol, rightcol;
     linenr_T top, bot;
 
@@ -1837,8 +1871,8 @@ void clear_showcmd(void)
       char *const saved_w_sbr = curwin->w_p_sbr;
 
       // Make 'sbr' empty for a moment to get the correct size.
-      p_sbr = empty_option;
-      curwin->w_p_sbr = empty_option;
+      p_sbr = empty_string_option;
+      curwin->w_p_sbr = empty_string_option;
       getvcols(curwin, &curwin->w_cursor, &VIsual, &leftcol, &rightcol);
       p_sbr = saved_sbr;
       curwin->w_p_sbr = saved_w_sbr;
@@ -1848,7 +1882,6 @@ void clear_showcmd(void)
       snprintf(showcmd_buf, SHOWCMD_BUFLEN, "%" PRId64, (int64_t)lines);
     } else {
       char *s, *e;
-      int l;
       int bytes = 0;
       int chars = 0;
 
@@ -1860,7 +1893,7 @@ void clear_showcmd(void)
         e = ml_get_pos(&VIsual);
       }
       while ((*p_sel != 'e') ? s <= e : s < e) {
-        l = utfc_ptr2len(s);
+        int l = utfc_ptr2len(s);
         if (l == 0) {
           bytes++;
           chars++;
@@ -1957,13 +1990,11 @@ void add_to_showcmd_c(int c)
 /// Delete 'len' characters from the end of the shown command.
 static void del_from_showcmd(int len)
 {
-  int old_len;
-
   if (!p_sc) {
     return;
   }
 
-  old_len = (int)strlen(showcmd_buf);
+  int old_len = (int)strlen(showcmd_buf);
   if (len > old_len) {
     len = old_len;
   }
@@ -2000,13 +2031,21 @@ static void display_showcmd(void)
   showcmd_is_clear = (len == 0);
 
   if (*p_sloc == 's') {
-    win_redr_status(curwin);
-    setcursor();  // put cursor back where it belongs
+    if (showcmd_is_clear) {
+      curwin->w_redr_status = true;
+    } else {
+      win_redr_status(curwin);
+      setcursor();  // put cursor back where it belongs
+    }
     return;
   }
   if (*p_sloc == 't') {
-    draw_tabline();
-    setcursor();  // put cursor back where it belongs
+    if (showcmd_is_clear) {
+      redraw_tabline = true;
+    } else {
+      draw_tabline();
+      setcursor();  // put cursor back where it belongs
+    }
     return;
   }
   // 'showcmdloc' is "last" or empty
@@ -2020,7 +2059,7 @@ static void display_showcmd(void)
     if (len > 0) {
       // placeholder for future highlight support
       ADD_C(chunk, INTEGER_OBJ(0));
-      ADD_C(chunk, STRING_OBJ(cstr_as_string(showcmd_buf)));
+      ADD_C(chunk, CSTR_AS_OBJ(showcmd_buf));
       ADD_C(content, ARRAY_OBJ(chunk));
     }
     ui_call_msg_showcmd(content);
@@ -2029,18 +2068,16 @@ static void display_showcmd(void)
 
   msg_grid_validate();
   int showcmd_row = Rows - 1;
-  grid_puts_line_start(&msg_grid_adj, showcmd_row);
+  grid_line_start(&msg_grid_adj, showcmd_row);
 
   if (!showcmd_is_clear) {
-    grid_puts(&msg_grid_adj, showcmd_buf, showcmd_row, sc_col,
-              HL_ATTR(HLF_MSG));
+    grid_line_puts(sc_col, showcmd_buf, -1, HL_ATTR(HLF_MSG));
   }
 
   // clear the rest of an old message by outputting up to SHOWCMD_COLS spaces
-  grid_puts(&msg_grid_adj, (char *)"          " + len, showcmd_row,
-            sc_col + len, HL_ATTR(HLF_MSG));
+  grid_line_puts(sc_col + len, (char *)"          " + len, -1, HL_ATTR(HLF_MSG));
 
-  grid_puts_line_flush(false);
+  grid_line_flush();
 }
 
 /// When "check" is false, prepare for commands that scroll the window.
@@ -2069,8 +2106,7 @@ void do_check_scrollbind(bool check)
           && (curwin->w_topline != old_topline
               || curwin->w_topfill != old_topfill
               || curwin->w_leftcol != old_leftcol)) {
-        check_scrollbind(curwin->w_topline - old_topline,
-                         (long)(curwin->w_leftcol - old_leftcol));
+        check_scrollbind(curwin->w_topline - old_topline, curwin->w_leftcol - old_leftcol);
       }
     } else if (vim_strchr(p_sbo, 'j')) {  // jump flag set in 'scrollopt'
       // When switching between windows, make sure that the relative
@@ -2081,7 +2117,7 @@ void do_check_scrollbind(bool check)
       // resync is performed, some of the other 'scrollbind' windows may
       // need to jump so that the current window's relative position is
       // visible on-screen.
-      check_scrollbind(curwin->w_topline - (linenr_T)curwin->w_scbind_pos, 0L);
+      check_scrollbind(curwin->w_topline - (linenr_T)curwin->w_scbind_pos, 0);
     }
     curwin->w_scbind_pos = curwin->w_topline;
   }
@@ -2096,22 +2132,20 @@ void do_check_scrollbind(bool check)
 /// Synchronize any windows that have "scrollbind" set, based on the
 /// number of rows by which the current window has changed
 /// (1998-11-02 16:21:01  R. Edward Ralston <eralston@computer.org>)
-void check_scrollbind(linenr_T topline_diff, long leftcol_diff)
+void check_scrollbind(linenr_T topline_diff, int leftcol_diff)
 {
-  bool want_ver;
-  bool want_hor;
   win_T *old_curwin = curwin;
   buf_T *old_curbuf = curbuf;
   int old_VIsual_select = VIsual_select;
   int old_VIsual_active = VIsual_active;
   colnr_T tgt_leftcol = curwin->w_leftcol;
-  long topline;
-  long y;
+  linenr_T topline;
+  linenr_T y;
 
   // check 'scrollopt' string for vertical and horizontal scroll options
-  want_ver = (vim_strchr(p_sbo, 'v') && topline_diff != 0);
+  bool want_ver = (vim_strchr(p_sbo, 'v') && topline_diff != 0);
   want_ver |= old_curwin->w_p_diff;
-  want_hor = (vim_strchr(p_sbo, 'h') && (leftcol_diff || topline_diff != 0));
+  bool want_hor = (vim_strchr(p_sbo, 'h') && (leftcol_diff || topline_diff != 0));
 
   // loop through the scrollbound windows and scroll accordingly
   VIsual_select = VIsual_active = 0;
@@ -2129,7 +2163,7 @@ void check_scrollbind(linenr_T topline_diff, long leftcol_diff)
         diff_set_topline(old_curwin, curwin);
       } else {
         curwin->w_scbind_pos += topline_diff;
-        topline = curwin->w_scbind_pos;
+        topline = (linenr_T)curwin->w_scbind_pos;
         if (topline > curbuf->b_ml.ml_line_count) {
           topline = curbuf->b_ml.ml_line_count;
         }
@@ -2151,9 +2185,8 @@ void check_scrollbind(linenr_T topline_diff, long leftcol_diff)
     }
 
     // do the horizontal scroll
-    if (want_hor && curwin->w_leftcol != tgt_leftcol) {
-      curwin->w_leftcol = tgt_leftcol;
-      leftcol_changed();
+    if (want_hor) {
+      (void)set_leftcol(tgt_leftcol);
     }
   }
 
@@ -2175,7 +2208,8 @@ static void nv_ignore(cmdarg_T *cap)
 /// Command character that doesn't do anything, but unlike nv_ignore() does
 /// start edit().  Used for "startinsert" executed while starting up.
 static void nv_nop(cmdarg_T *cap)
-{}
+{
+}
 
 /// Command character doesn't exist.
 static void nv_error(cmdarg_T *cap)
@@ -2199,7 +2233,7 @@ static void nv_addsub(cmdarg_T *cap)
   } else if (!VIsual_active && cap->oap->op_type == OP_NOP) {
     prep_redo_cmd(cap);
     cap->oap->op_type = cap->cmdchar == Ctrl_A ? OP_NR_ADD : OP_NR_SUB;
-    op_addsub(cap->oap, (linenr_T)cap->count1, cap->arg);
+    op_addsub(cap->oap, cap->count1, cap->arg);
     cap->oap->op_type = OP_NOP;
   } else if (VIsual_active) {
     nv_operator(cap);
@@ -2218,9 +2252,9 @@ static void nv_page(cmdarg_T *cap)
   if (mod_mask & MOD_MASK_CTRL) {
     // <C-PageUp>: tab page back; <C-PageDown>: tab page forward
     if (cap->arg == BACKWARD) {
-      goto_tabpage(-(int)cap->count1);
+      goto_tabpage(-cap->count1);
     } else {
-      goto_tabpage((int)cap->count0);
+      goto_tabpage(cap->count0);
     }
   } else {
     (void)onepage(cap->arg, cap->count1);
@@ -2292,34 +2326,30 @@ static bool is_ident(const char *line, int offset)
 /// @return           fail when not found.
 bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_arg)
 {
-  char *pat;
-  pos_T old_pos;
   pos_T par_pos;
   pos_T found_pos;
   bool t;
-  bool save_p_ws;
-  bool save_p_scs;
   bool retval = true;
   bool incll;
   int searchflags = flags_arg;
 
-  pat = xmalloc(len + 7);
+  size_t patlen = len + 7;
+  char *pat = xmalloc(patlen);
 
   // Put "\V" before the pattern to avoid that the special meaning of "."
   // and "~" causes trouble.
-  assert(len <= INT_MAX);
-  sprintf(pat, vim_iswordp(ptr) ? "\\V\\<%.*s\\>" : "\\V%.*s",  // NOLINT(runtime/printf)
-          (int)len, ptr);
-  old_pos = curwin->w_cursor;
-  save_p_ws = p_ws;
-  save_p_scs = p_scs;
+  assert(patlen <= INT_MAX);
+  snprintf(pat, patlen, vim_iswordp(ptr) ? "\\V\\<%.*s\\>" : "\\V%.*s", (int)len, ptr);
+  pos_T old_pos = curwin->w_cursor;
+  bool save_p_ws = p_ws;
+  bool save_p_scs = p_scs;
   p_ws = false;         // don't wrap around end of file now
   p_scs = false;        // don't switch ignorecase off now
 
   // With "gD" go to line 1.
   // With "gd" Search back for the start of the current function, then go
   // back until a blank line.  If this fails go to line 1.
-  if (!locally || !findpar(&incll, BACKWARD, 1L, '{', false)) {
+  if (!locally || !findpar(&incll, BACKWARD, 1, '{', false)) {
     setpcmark();                        // Set in findpar() otherwise
     curwin->w_cursor.lnum = 1;
     par_pos = curwin->w_cursor;
@@ -2334,9 +2364,9 @@ bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_ar
 
   // Search forward for the identifier, ignore comment lines.
   clearpos(&found_pos);
-  for (;;) {
+  while (true) {
     t = searchit(curwin, curbuf, &curwin->w_cursor, NULL, FORWARD,
-                 pat, 1L, searchflags, RE_LAST, NULL);
+                 pat, 1, searchflags, RE_LAST, NULL);
     if (curwin->w_cursor.lnum >= old_pos.lnum) {
       t = false;         // match after start is failure too
     }
@@ -2422,12 +2452,11 @@ bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_ar
 /// 'dist' must be positive.
 ///
 /// @return  true if able to move cursor, false otherwise.
-static bool nv_screengo(oparg_T *oap, int dir, long dist)
+static bool nv_screengo(oparg_T *oap, int dir, int dist)
 {
-  int linelen = linetabsize(get_cursor_line_ptr());
+  int linelen = linetabsize(curwin, curwin->w_cursor.lnum);
   bool retval = true;
   bool atend = false;
-  int n;
   int col_off1;                 // margin offset for first screen line
   int col_off2;                 // margin offset for wrapped screen line
   int width1;                   // text width for first screen line
@@ -2446,6 +2475,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
   }
 
   if (curwin->w_width_inner != 0) {
+    int n;
     // Instead of sticking at the last character of the buffer line we
     // try to stick in the last column of the screen.
     if (curwin->w_curswant == MAXCOL) {
@@ -2482,20 +2512,13 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
           curwin->w_curswant -= width2;
         } else {
           // to previous line
-
-          // Move to the start of a closed fold.  Don't do that when
-          // 'foldopen' contains "all": it will open in a moment.
-          if (!(fdo_flags & FDO_ALL)) {
-            (void)hasFolding(curwin->w_cursor.lnum,
-                             &curwin->w_cursor.lnum, NULL);
-          }
-          if (curwin->w_cursor.lnum == 1) {
+          if (curwin->w_cursor.lnum <= 1) {
             retval = false;
             break;
           }
-          curwin->w_cursor.lnum--;
+          cursor_up_inner(curwin, 1);
 
-          linelen = linetabsize(get_cursor_line_ptr());
+          linelen = linetabsize(curwin, curwin->w_cursor.lnum);
           if (linelen > width1) {
             int w = (((linelen - width1 - 1) / width2) + 1) * width2;
             assert(curwin->w_curswant <= INT_MAX - w);
@@ -2514,16 +2537,13 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
           curwin->w_curswant += width2;
         } else {
           // to next line
-
-          // Move to the end of a closed fold.
-          (void)hasFolding(curwin->w_cursor.lnum, NULL,
-                           &curwin->w_cursor.lnum);
-          if (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) {
+          if (curwin->w_cursor.lnum >= curwin->w_buffer->b_ml.ml_line_count) {
             retval = false;
             break;
           }
-          curwin->w_cursor.lnum++;
+          cursor_down_inner(curwin, 1);
           curwin->w_curswant %= width2;
+
           // Check if the cursor has moved below the number display
           // when width1 < width2 (with cpoptions+=n). Subtract width2
           // to get a negative value for w_curswant, which will get
@@ -2531,7 +2551,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
           if (curwin->w_curswant >= width1) {
             curwin->w_curswant -= width2;
           }
-          linelen = linetabsize(get_cursor_line_ptr());
+          linelen = linetabsize(curwin, curwin->w_cursor.lnum);
         }
       }
     }
@@ -2572,63 +2592,14 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
   if (atend) {
     curwin->w_curswant = MAXCOL;            // stick in the last column
   }
-  return retval;
-}
-
-/// Mouse scroll wheel: Default action is to scroll three lines, or one page
-/// when Shift or Ctrl is used.
-/// K_MOUSEUP (cap->arg == 1) or K_MOUSEDOWN (cap->arg == 0) or
-/// K_MOUSELEFT (cap->arg == -1) or K_MOUSERIGHT (cap->arg == -2)
-static void nv_mousescroll(cmdarg_T *cap)
-{
-  win_T *old_curwin = curwin;
-
-  if (mouse_row >= 0 && mouse_col >= 0) {
-    int grid, row, col;
-
-    grid = mouse_grid;
-    row = mouse_row;
-    col = mouse_col;
-
-    // find the window at the pointer coordinates
-    win_T *wp = mouse_find_win(&grid, &row, &col);
-    if (wp == NULL) {
-      return;
-    }
-    curwin = wp;
-    curbuf = curwin->w_buffer;
-  }
+  adjust_skipcol();
 
-  if (cap->arg == MSCR_UP || cap->arg == MSCR_DOWN) {
-    if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) {
-      (void)onepage(cap->arg ? FORWARD : BACKWARD, 1L);
-    } else if (p_mousescroll_vert > 0) {
-      cap->count1 = p_mousescroll_vert;
-      cap->count0 = p_mousescroll_vert;
-      nv_scroll_line(cap);
-    }
-  } else {
-    mouse_scroll_horiz(cap->arg);
-  }
-  if (curwin != old_curwin && curwin->w_p_cul) {
-    redraw_for_cursorline(curwin);
-  }
-
-  curwin->w_redr_status = true;
-
-  curwin = old_curwin;
-  curbuf = curwin->w_buffer;
-}
-
-/// Mouse clicks and drags.
-static void nv_mouse(cmdarg_T *cap)
-{
-  (void)do_mouse(cap->oap, cap->cmdchar, BACKWARD, cap->count1, 0);
+  return retval;
 }
 
 /// Handle CTRL-E and CTRL-Y commands: scroll a line up or down.
 /// cap->arg must be true for CTRL-E.
-static void nv_scroll_line(cmdarg_T *cap)
+void nv_scroll_line(cmdarg_T *cap)
 {
   if (!checkclearop(cap->oap)) {
     scroll_redraw(cap->arg, cap->count1);
@@ -2636,17 +2607,18 @@ static void nv_scroll_line(cmdarg_T *cap)
 }
 
 /// Scroll "count" lines up or down, and redraw.
-void scroll_redraw(int up, long count)
+void scroll_redraw(int up, linenr_T count)
 {
   linenr_T prev_topline = curwin->w_topline;
+  int prev_skipcol = curwin->w_skipcol;
   int prev_topfill = curwin->w_topfill;
   linenr_T prev_lnum = curwin->w_cursor.lnum;
 
-  bool moved = up ?
-               scrollup(count, true) :
-               scrolldown(count, true);
+  bool moved = up
+               ? scrollup(count, true)
+               : scrolldown(count, true);
 
-  if (get_scrolloff_value(curwin)) {
+  if (get_scrolloff_value(curwin) > 0) {
     // Adjust the cursor position for 'scrolloff'.  Mark w_topline as
     // valid, otherwise the screen jumps back at the end of the file.
     cursor_correct();
@@ -2657,16 +2629,17 @@ void scroll_redraw(int up, long count)
     // we get stuck at one position.  Don't move the cursor up if the
     // first line of the buffer is already on the screen
     while (curwin->w_topline == prev_topline
+           && curwin->w_skipcol == prev_skipcol
            && curwin->w_topfill == prev_topfill) {
       if (up) {
         if (curwin->w_cursor.lnum > prev_lnum
-            || cursor_down(1L, false) == false) {
+            || cursor_down(1, false) == false) {
           break;
         }
       } else {
         if (curwin->w_cursor.lnum < prev_lnum
-            || prev_topline == 1L
-            || cursor_up(1L, false) == false) {
+            || prev_topline == 1
+            || cursor_up(1, false) == false) {
           break;
         }
       }
@@ -2696,9 +2669,9 @@ static bool nv_z_get_count(cmdarg_T *cap, int *nchar_arg)
   if (checkclearop(cap->oap)) {
     return false;
   }
-  long n = nchar - '0';
+  int n = nchar - '0';
 
-  for (;;) {
+  while (true) {
     no_mapping++;
     allow_keys++;         // no mapping for nchar, but allow key codes
     nchar = plain_vgetc();
@@ -2710,9 +2683,13 @@ static bool nv_z_get_count(cmdarg_T *cap, int *nchar_arg)
     if (nchar == K_DEL || nchar == K_KDEL) {
       n /= 10;
     } else if (ascii_isdigit(nchar)) {
+      if (n > INT_MAX / 10) {
+        clearopbeep(cap->oap);
+        break;
+      }
       n = n * 10 + (nchar - '0');
     } else if (nchar == CAR) {
-      win_setheight((int)n);
+      win_setheight(n);
       break;
     } else if (nchar == 'l'
                || nchar == 'h'
@@ -2784,7 +2761,7 @@ static int nv_zg_zw(cmdarg_T *cap, int nchar)
   assert(len <= INT_MAX);
   spell_add_word(ptr, (int)len,
                  nchar == 'w' || nchar == 'W' ? SPELL_ADD_BAD : SPELL_ADD_GOOD,
-                 (nchar == 'G' || nchar == 'W') ? 0 : (int)cap->count1,
+                 (nchar == 'G' || nchar == 'W') ? 0 : cap->count1,
                  undo);
 
   return OK;
@@ -2793,13 +2770,12 @@ static int nv_zg_zw(cmdarg_T *cap, int nchar)
 /// Commands that start with "z".
 static void nv_zet(cmdarg_T *cap)
 {
-  int n;
   colnr_T col;
   int nchar = cap->nchar;
-  long old_fdl = curwin->w_p_fdl;
+  int old_fdl = (int)curwin->w_p_fdl;
   int old_fen = curwin->w_p_fen;
 
-  int siso = (int)get_sidescrolloff_value(curwin);
+  int siso = get_sidescrolloff_value(curwin);
 
   if (ascii_isdigit(nchar) && !nv_z_get_count(cap, &nchar)) {
     return;
@@ -2824,7 +2800,7 @@ static void nv_zet(cmdarg_T *cap)
     if (cap->count0 > curbuf->b_ml.ml_line_count) {
       curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
     } else {
-      curwin->w_cursor.lnum = (linenr_T)cap->count0;
+      curwin->w_cursor.lnum = cap->count0;
     }
     check_cursor_col();
   }
@@ -2860,7 +2836,7 @@ static void nv_zet(cmdarg_T *cap)
     FALLTHROUGH;
 
   case 'z':
-    scroll_cursor_halfway(true);
+    scroll_cursor_halfway(true, false);
     redraw_later(curwin, UPD_VALID);
     set_fraction(curwin);
     break;
@@ -2897,27 +2873,21 @@ static void nv_zet(cmdarg_T *cap)
   case 'h':
   case K_LEFT:
     if (!curwin->w_p_wrap) {
-      if ((colnr_T)cap->count1 > curwin->w_leftcol) {
-        curwin->w_leftcol = 0;
-      } else {
-        curwin->w_leftcol -= (colnr_T)cap->count1;
-      }
-      leftcol_changed();
+      (void)set_leftcol((colnr_T)cap->count1 > curwin->w_leftcol
+                        ? 0 : curwin->w_leftcol - (colnr_T)cap->count1);
     }
     break;
 
-  // "zL" - scroll screen left half-page
+  // "zL" - scroll window left half-page
   case 'L':
     cap->count1 *= curwin->w_width_inner / 2;
     FALLTHROUGH;
 
-  // "zl" - scroll screen to the left
+  // "zl" - scroll window to the left if not wrapping
   case 'l':
   case K_RIGHT:
     if (!curwin->w_p_wrap) {
-      // scroll the window left
-      curwin->w_leftcol += (colnr_T)cap->count1;
-      leftcol_changed();
+      (void)set_leftcol(curwin->w_leftcol + (colnr_T)cap->count1);
     }
     break;
 
@@ -2949,7 +2919,7 @@ static void nv_zet(cmdarg_T *cap)
       } else {
         getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col);
       }
-      n = curwin->w_width_inner - curwin_col_off();
+      int n = curwin->w_width_inner - curwin_col_off();
       if (col + siso < n) {
         col = 0;
       } else {
@@ -3011,7 +2981,7 @@ static void nv_zet(cmdarg_T *cap)
       clearFolding(curwin);
       changed_window_setting();
     } else if (foldmethodIsMarker(curwin)) {
-      deleteFold(curwin, (linenr_T)1, curbuf->b_ml.ml_line_count, true, false);
+      deleteFold(curwin, 1, curbuf->b_ml.ml_line_count, true, false);
     } else {
       emsg(_("E352: Cannot erase folds with current 'foldmethod'"));
     }
@@ -3165,7 +3135,7 @@ static void nv_zet(cmdarg_T *cap)
 
   case '=':     // "z=": suggestions for a badly spelled word
     if (!checkclearop(cap->oap)) {
-      spell_suggest((int)cap->count0);
+      spell_suggest(cap->count0);
     }
     break;
 
@@ -3230,7 +3200,7 @@ static void nv_colon(cmdarg_T *cap)
     stuffcharReadbuff('.');
     if (cap->count0 > 1) {
       stuffReadbuff(",.+");
-      stuffnumReadbuff(cap->count0 - 1L);
+      stuffnumReadbuff(cap->count0 - 1);
     }
   }
 
@@ -3240,7 +3210,7 @@ static void nv_colon(cmdarg_T *cap)
   }
 
   if (is_lua) {
-    cmd_result = map_execute_lua();
+    cmd_result = map_execute_lua(true);
   } else {
     // get a command line and execute it
     cmd_result = do_cmdline(NULL, is_cmdkey ? getcmdkeycmd : getexline, NULL,
@@ -3269,7 +3239,7 @@ static void nv_ctrlg(cmdarg_T *cap)
     showmode();
   } else if (!checkclearop(cap->oap)) {
     // print full name if count given or :cd used
-    fileinfo((int)cap->count0, false, true);
+    fileinfo(cap->count0, false, true);
   }
 }
 
@@ -3319,7 +3289,7 @@ static void nv_ctrlo(cmdarg_T *cap)
 static void nv_hat(cmdarg_T *cap)
 {
   if (!checkclearopq(cap->oap)) {
-    (void)buflist_getfile((int)cap->count0, (linenr_T)0,
+    (void)buflist_getfile(cap->count0, 0,
                           GETF_SETMARK|GETF_ALT, false);
   }
 }
@@ -3438,7 +3408,6 @@ static void nv_ident(cmdarg_T *cap)
   int cmdchar;
   bool g_cmd;                   // "g" command
   bool tag_cmd = false;
-  char *aux_ptr;
 
   if (cap->cmdchar == 'g') {    // "g*", "g#", "g]" and "gCTRL-]"
     cmdchar = cap->nchar;
@@ -3531,7 +3500,7 @@ static void nv_ident(cmdarg_T *cap)
     ptr = xstrnsave(ptr, n);
     if (kp_ex) {
       // Escape the argument properly for an Ex command
-      p = vim_strsave_fnameescape((const char *)ptr, VSE_NONE);
+      p = vim_strsave_fnameescape(ptr, VSE_NONE);
     } else {
       // Escape the argument properly for a shell command
       p = vim_strsave_shellescape(ptr, true, true);
@@ -3542,6 +3511,7 @@ static void nv_ident(cmdarg_T *cap)
     STRCAT(buf, p);
     xfree(p);
   } else {
+    char *aux_ptr;
     if (cmdchar == '*') {
       aux_ptr = (magic_isset() ? "/.*~[^$\\" : "/^$\\");
     } else if (cmdchar == '#') {
@@ -3646,17 +3616,15 @@ bool get_visual_text(cmdarg_T *cap, char **pp, size_t *lenp)
 static void nv_tagpop(cmdarg_T *cap)
 {
   if (!checkclearopq(cap->oap)) {
-    do_tag("", DT_POP, (int)cap->count1, false, true);
+    do_tag("", DT_POP, cap->count1, false, true);
   }
 }
 
 /// Handle scrolling command 'H', 'L' and 'M'.
 static void nv_scroll(cmdarg_T *cap)
 {
-  int used = 0;
-  long n;
+  int n;
   linenr_T lnum;
-  int half;
 
   cap->oap->motion_type = kMTLineWise;
   setpcmark();
@@ -3678,28 +3646,29 @@ static void nv_scroll(cmdarg_T *cap)
           }
         }
       } else {
-        curwin->w_cursor.lnum -= (linenr_T)cap->count1 - 1;
+        curwin->w_cursor.lnum -= cap->count1 - 1;
       }
     }
   } else {
     if (cap->cmdchar == 'M') {
+      int used = 0;
       // Don't count filler lines above the window.
       used -= win_get_fill(curwin, curwin->w_topline)
               - curwin->w_topfill;
       validate_botline(curwin);  // make sure w_empty_rows is valid
-      half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2;
+      int half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2;
       for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; n++) {
         // Count half the number of filler lines to be "below this
         // line" and half to be "above the next line".
-        if (n > 0 && used + win_get_fill(curwin, curwin->w_topline + (linenr_T)n) / 2 >= half) {
+        if (n > 0 && used + win_get_fill(curwin, curwin->w_topline + n) / 2 >= half) {
           n--;
           break;
         }
-        used += plines_win(curwin, curwin->w_topline + (linenr_T)n, true);
+        used += plines_win(curwin, curwin->w_topline + n, true);
         if (used >= half) {
           break;
         }
-        if (hasFolding(curwin->w_topline + (linenr_T)n, NULL, &lnum)) {
+        if (hasFolding(curwin->w_topline + n, NULL, &lnum)) {
           n = lnum - curwin->w_topline;
         }
       }
@@ -3718,7 +3687,7 @@ static void nv_scroll(cmdarg_T *cap)
         n = lnum - curwin->w_topline;
       }
     }
-    curwin->w_cursor.lnum = curwin->w_topline + (linenr_T)n;
+    curwin->w_cursor.lnum = curwin->w_topline + n;
     if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
       curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
     }
@@ -3734,7 +3703,7 @@ static void nv_scroll(cmdarg_T *cap)
 /// Cursor right commands.
 static void nv_right(cmdarg_T *cap)
 {
-  long n;
+  int n;
 
   if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) {
     // <C-Right> and <S-Right> move a word or WORD right
@@ -3812,7 +3781,7 @@ static void nv_right(cmdarg_T *cap)
 /// @return  true when operator end should not be adjusted.
 static void nv_left(cmdarg_T *cap)
 {
-  long n;
+  int n;
 
   if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) {
     // <C-Left> and <S-Left> move a word or WORD left
@@ -3921,14 +3890,13 @@ static void nv_down(cmdarg_T *cap)
 /// Grab the file name under the cursor and edit it.
 static void nv_gotofile(cmdarg_T *cap)
 {
-  char *ptr;
   linenr_T lnum = -1;
 
   if (check_text_or_curbuf_locked(cap->oap)) {
     return;
   }
 
-  ptr = grab_file_name(cap->count1, &lnum);
+  char *ptr = grab_file_name(cap->count1, &lnum);
 
   if (ptr != NULL) {
     // do autowrite if necessary
@@ -3940,7 +3908,7 @@ static void nv_gotofile(cmdarg_T *cap)
                 buf_hide(curbuf) ? ECMD_HIDE : 0, curwin) == OK
         && cap->nchar == 'F' && lnum >= 0) {
       curwin->w_cursor.lnum = lnum;
-      check_cursor_lnum();
+      check_cursor_lnum(curwin);
       beginline(BL_SOL | BL_FIX);
     }
     xfree(ptr);
@@ -4113,9 +4081,8 @@ static void nv_bracket_block(cmdarg_T *cap, const pos_T *old_pos)
   pos_T new_pos = { 0, 0, 0 };
   pos_T *pos = NULL;  // init for GCC
   pos_T prev_pos;
-  long n;
+  int n;
   int findc;
-  int c;
 
   if (cap->nchar == '*') {
     cap->nchar = '/';
@@ -4155,6 +4122,7 @@ static void nv_bracket_block(cmdarg_T *cap, const pos_T *old_pos)
   // Try finding the '{' or '}' we want to be at.
   // Also repeat for the given count.
   if (cap->nchar == 'm' || cap->nchar == 'M') {
+    int c;
     // norm is true for "]M" and "[m"
     int norm = ((findc == '{') == (cap->nchar == 'm'));
 
@@ -4170,7 +4138,7 @@ static void nv_bracket_block(cmdarg_T *cap, const pos_T *old_pos)
       pos = NULL;
     }
     while (n > 0) {
-      for (;;) {
+      while (true) {
         if ((findc == '{' ? dec_cursor() : inc_cursor()) < 0) {
           // if not found anything, that's an error
           if (pos == NULL) {
@@ -4225,13 +4193,12 @@ static void nv_bracket_block(cmdarg_T *cap, const pos_T *old_pos)
 /// cap->arg is BACKWARD for "[" and FORWARD for "]".
 static void nv_brackets(cmdarg_T *cap)
 {
-  pos_T old_pos;                    // cursor position before command
   int flag;
-  long n;
+  int n;
 
   cap->oap->motion_type = kMTCharWise;
   cap->oap->inclusive = false;
-  old_pos = curwin->w_cursor;
+  pos_T old_pos = curwin->w_cursor;         // cursor position before command
   curwin->w_cursor.coladd = 0;              // TODO(Unknown): don't do this for an error.
 
   // "[f" or "]f" : Edit file under the cursor (same as "gf")
@@ -4252,19 +4219,19 @@ static void nv_brackets(cmdarg_T *cap)
       clearop(cap->oap);
     } else {
       // Make a copy, if the line was changed it will be freed.
-      ptr = xstrnsave(ptr, len);
+      ptr = xmemdupz(ptr, len);
       find_pattern_in_path(ptr, 0, len, true,
                            cap->count0 == 0 ? !isupper(cap->nchar) : false,
                            (((cap->nchar & 0xf) == ('d' & 0xf))
                             ? FIND_DEFINE
                             : FIND_ANY),
                            cap->count1,
-                           (isupper(cap->nchar) ? ACTION_SHOW_ALL :
-                            islower(cap->nchar) ? ACTION_SHOW :
-                            ACTION_GOTO),
+                           (isupper(cap->nchar) ? ACTION_SHOW_ALL
+                                                : islower(cap->nchar) ? ACTION_SHOW
+                                                                      : ACTION_GOTO),
                            (cap->cmdchar == ']'
                             ? curwin->w_cursor.lnum + 1
-                            : (linenr_T)1),
+                            : 1),
                            MAXLNUM);
       xfree(ptr);
       curwin->w_set_curswant = true;
@@ -4318,7 +4285,7 @@ static void nv_brackets(cmdarg_T *cap)
       fm = prev_fm;
     }
     MarkMove flags = kMarkContext;
-    flags |= cap->nchar == '\'' ? kMarkBeginLine: 0;
+    flags |= cap->nchar == '\'' ? kMarkBeginLine : 0;
     nv_mark_move_to(cap, flags, fm);
   } else if (cap->nchar >= K_RIGHTRELEASE && cap->nchar <= K_LEFTMOUSE) {
     // [ or ] followed by a middle mouse click: put selected text with
@@ -4361,7 +4328,6 @@ static void nv_brackets(cmdarg_T *cap)
 /// Handle Normal mode "%" command.
 static void nv_percent(cmdarg_T *cap)
 {
-  pos_T *pos;
   linenr_T lnum = curwin->w_cursor.lnum;
 
   cap->oap->inclusive = true;
@@ -4377,10 +4343,10 @@ static void nv_percent(cmdarg_T *cap)
       // to avoid overflows.
       if (curbuf->b_ml.ml_line_count >= 21474836) {
         curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count + 99)
-                                / 100 * (linenr_T)cap->count0;
+                                / 100 * cap->count0;
       } else {
         curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count *
-                                 (linenr_T)cap->count0 + 99) / 100;
+                                 cap->count0 + 99) / 100;
       }
       if (curwin->w_cursor.lnum < 1) {
         curwin->w_cursor.lnum = 1;
@@ -4391,6 +4357,7 @@ static void nv_percent(cmdarg_T *cap)
       beginline(BL_SOL | BL_FIX);
     }
   } else {  // "%" : go to matching paren
+    pos_T *pos;
     cap->oap->motion_type = kMTCharWise;
     cap->oap->use_reg_one = true;
     if ((pos = findmatch(cap->oap, NUL)) == NULL) {
@@ -4490,14 +4457,13 @@ static void nv_kundo(cmdarg_T *cap)
     clearopbeep(cap->oap);
     return;
   }
-  u_undo((int)cap->count1);
+  u_undo(cap->count1);
   curwin->w_set_curswant = true;
 }
 
 /// Handle the "r" command.
 static void nv_replace(cmdarg_T *cap)
 {
-  char *ptr;
   int had_ctrl_v;
 
   if (checkclearop(cap->oap)) {
@@ -4509,7 +4475,7 @@ static void nv_replace(cmdarg_T *cap)
   }
 
   // get another character
-  if (cap->nchar == Ctrl_V) {
+  if (cap->nchar == Ctrl_V || cap->nchar == Ctrl_Q) {
     had_ctrl_v = Ctrl_V;
     cap->nchar = get_literal(false);
     // Don't redo a multibyte character with CTRL-V.
@@ -4529,7 +4495,7 @@ static void nv_replace(cmdarg_T *cap)
   // Visual mode "r"
   if (VIsual_active) {
     if (got_int) {
-      reset_VIsual();
+      got_int = false;
     }
     if (had_ctrl_v) {
       // Use a special (negative) number to make a difference between a
@@ -4560,7 +4526,7 @@ static void nv_replace(cmdarg_T *cap)
   }
 
   // Abort if not enough characters to replace.
-  ptr = get_cursor_pos_ptr();
+  char *ptr = get_cursor_pos_ptr();
   if (strlen(ptr) < (unsigned)cap->count1
       || (mb_charlen(ptr) < cap->count1)) {
     clearopbeep(cap->oap);
@@ -4614,7 +4580,7 @@ static void nv_replace(cmdarg_T *cap)
     // This is slow, but it handles replacing a single-byte with a
     // multi-byte and the other way around.  Also handles adding
     // composing characters for utf-8.
-    for (long n = cap->count1; n > 0; n--) {
+    for (int n = cap->count1; n > 0; n--) {
       State = MODE_REPLACE;
       if (cap->nchar == Ctrl_E || cap->nchar == Ctrl_Y) {
         int c = ins_copychar(curwin->w_cursor.lnum
@@ -4652,11 +4618,10 @@ static void nv_replace(cmdarg_T *cap)
 /// 'O': same, but in block mode exchange left and right corners.
 static void v_swap_corners(int cmdchar)
 {
-  pos_T old_cursor;
   colnr_T left, right;
 
   if (cmdchar == 'O' && VIsual_mode == Ctrl_V) {
-    old_cursor = curwin->w_cursor;
+    pos_T old_cursor = curwin->w_cursor;
     getvcols(curwin, &old_cursor, &VIsual, &left, &right);
     curwin->w_cursor.lnum = VIsual.lnum;
     coladvance(left);
@@ -4686,7 +4651,7 @@ static void v_swap_corners(int cmdchar)
       curwin->w_curswant = left;
     }
   } else {
-    old_cursor = curwin->w_cursor;
+    pos_T old_cursor = curwin->w_cursor;
     curwin->w_cursor = VIsual;
     VIsual = old_cursor;
     curwin->w_set_curswant = true;
@@ -4736,9 +4701,15 @@ static void nv_vreplace(cmdarg_T *cap)
   if (!MODIFIABLE(curbuf)) {
     emsg(_(e_modifiable));
   } else {
-    if (cap->extra_char == Ctrl_V) {          // get another character
+    if (cap->extra_char == Ctrl_V || cap->extra_char == Ctrl_Q) {
+      // get another character
       cap->extra_char = get_literal(false);
     }
+    if (cap->extra_char < ' ') {
+      // Prefix a control character with CTRL-V to avoid it being used as
+      // a command.
+      stuffcharReadbuff(Ctrl_V);
+    }
     stuffcharReadbuff(cap->extra_char);
     stuffcharReadbuff(ESC);
     if (virtual_active()) {
@@ -4751,8 +4722,6 @@ static void nv_vreplace(cmdarg_T *cap)
 /// Swap case for "~" command, when it does not work like an operator.
 static void n_swapchar(cmdarg_T *cap)
 {
-  long n;
-  pos_T startpos;
   int did_change = 0;
 
   if (checkclearopq(cap->oap)) {
@@ -4770,8 +4739,8 @@ static void n_swapchar(cmdarg_T *cap)
     return;
   }
 
-  startpos = curwin->w_cursor;
-  for (n = cap->count1; n > 0; n--) {
+  pos_T startpos = curwin->w_cursor;
+  for (int n = cap->count1; n > 0; n--) {
     did_change |= swapchar(cap->oap->op_type, &curwin->w_cursor);
     inc_cursor();
     if (gchar_cursor() == NUL) {
@@ -4783,7 +4752,7 @@ static void n_swapchar(cmdarg_T *cap)
           if (u_savesub(curwin->w_cursor.lnum) == false) {
             break;
           }
-          u_clearline();
+          u_clearline(curbuf);
         }
       } else {
         break;
@@ -4794,8 +4763,8 @@ static void n_swapchar(cmdarg_T *cap)
   check_cursor();
   curwin->w_set_curswant = true;
   if (did_change) {
-    changed_lines(startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1,
-                  0L, true);
+    changed_lines(curbuf, startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1,
+                  0, true);
     curbuf->b_op_start = startpos;
     curbuf->b_op_end = curwin->w_cursor;
     if (curbuf->b_op_end.col > 0) {
@@ -4957,9 +4926,9 @@ static void nv_pcmark(cmdarg_T *cap)
   }
 
   if (cap->cmdchar == 'g') {
-    fm = get_changelist(curbuf, curwin, (int)cap->count1);
+    fm = get_changelist(curbuf, curwin, cap->count1);
   } else {
-    fm = get_jumplist(curwin, (int)cap->count1);
+    fm = get_jumplist(curwin, cap->count1);
     flags |= KMarkNoContext | kMarkJumpList;
   }
   // Changelist and jumplist have their own error messages. Therefore avoid
@@ -4969,7 +4938,7 @@ static void nv_pcmark(cmdarg_T *cap)
     move_res = nv_mark_move_to(cap, flags, fm);
   } else if (cap->cmdchar == 'g') {
     if (curbuf->b_changelistlen == 0) {
-      emsg(_("E664: changelist is empty"));
+      emsg(_(e_changelist_is_empty));
     } else if (cap->count1 < 0) {
       emsg(_("E662: At start of changelist"));
     } else {
@@ -5051,7 +5020,7 @@ static void nv_visual(cmdarg_T *cap)
       // For V and ^V, we multiply the number of lines even if there
       // was only one -- webb
       if (resel_VIsual_mode != 'v' || resel_VIsual_line_count > 1) {
-        curwin->w_cursor.lnum += resel_VIsual_line_count * (linenr_T)cap->count0 - 1;
+        curwin->w_cursor.lnum += resel_VIsual_line_count * cap->count0 - 1;
         check_cursor();
       }
       VIsual_mode = resel_VIsual_mode;
@@ -5059,7 +5028,7 @@ static void nv_visual(cmdarg_T *cap)
         if (resel_VIsual_line_count <= 1) {
           update_curswant_force();
           assert(cap->count0 >= INT_MIN && cap->count0 <= INT_MAX);
-          curwin->w_curswant += resel_VIsual_vcol * (int)cap->count0;
+          curwin->w_curswant += resel_VIsual_vcol * cap->count0;
           if (*p_sel != 'e') {
             curwin->w_curswant--;
           }
@@ -5072,9 +5041,13 @@ static void nv_visual(cmdarg_T *cap)
         curwin->w_curswant = MAXCOL;
         coladvance(MAXCOL);
       } else if (VIsual_mode == Ctrl_V) {
+        // Update curswant on the original line, that is where "col" is valid.
+        linenr_T lnum = curwin->w_cursor.lnum;
+        curwin->w_cursor.lnum = VIsual.lnum;
         update_curswant_force();
         assert(cap->count0 >= INT_MIN && cap->count0 <= INT_MAX);
-        curwin->w_curswant += resel_VIsual_vcol * (int)cap->count0 - 1;
+        curwin->w_curswant += resel_VIsual_vcol * cap->count0 - 1;
+        curwin->w_cursor.lnum = lnum;
         coladvance(curwin->w_curswant);
       } else {
         curwin->w_set_curswant = true;
@@ -5268,10 +5241,11 @@ static void nv_g_home_m_cmd(cmdarg_T *cap)
   if (flag) {
     do {
       i = gchar_cursor();
-    } while (ascii_iswhite(i) && oneright());
+    } while (ascii_iswhite(i) && oneright() == OK);
     curwin->w_valid &= ~VALID_WCOL;
   }
   curwin->w_set_curswant = true;
+  adjust_skipcol();
 }
 
 /// "g_": to the last non-blank character in the line or <count> lines downward.
@@ -5306,6 +5280,7 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
   oparg_T *oap = cap->oap;
   int i;
   int col_off = curwin_col_off();
+  const bool flag = cap->nchar == K_END || cap->nchar == K_KEND;
 
   oap->motion_type = kMTCharWise;
   oap->inclusive = true;
@@ -5344,11 +5319,11 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
     coladvance((colnr_T)i);
 
     // if the character doesn't fit move one back
-    if (curwin->w_cursor.col > 0 && utf_ptr2cells((const char *)get_cursor_pos_ptr()) > 1) {
+    if (curwin->w_cursor.col > 0 && utf_ptr2cells(get_cursor_pos_ptr()) > 1) {
       colnr_T vcol;
 
       getvvcol(curwin, &curwin->w_cursor, NULL, NULL, &vcol);
-      if (vcol >= curwin->w_leftcol + curwin->w_width - col_off) {
+      if (vcol >= curwin->w_leftcol + curwin->w_width_inner - col_off) {
         curwin->w_cursor.col--;
       }
     }
@@ -5356,6 +5331,12 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
     // Make sure we stick in this column.
     update_curswant_force();
   }
+  if (flag) {
+    do {
+      i = gchar_cursor();
+    } while (ascii_iswhite(i) && oneleft() == OK);
+    curwin->w_valid &= ~VALID_WCOL;
+  }
 }
 
 /// "gi": start Insert at the last position.
@@ -5363,7 +5344,7 @@ static void nv_gi_cmd(cmdarg_T *cap)
 {
   if (curbuf->b_last_insert.mark.lnum != 0) {
     curwin->w_cursor = curbuf->b_last_insert.mark;
-    check_cursor_lnum();
+    check_cursor_lnum(curwin);
     int i = (int)strlen(get_cursor_line_ptr());
     if (curwin->w_cursor.col > (colnr_T)i) {
       if (virtual_active()) {
@@ -5492,7 +5473,7 @@ static void nv_g_cmd(cmdarg_T *cap)
   case 'M':
     oap->motion_type = kMTCharWise;
     oap->inclusive = false;
-    i = linetabsize(get_cursor_line_ptr());
+    i = linetabsize(curwin, curwin->w_cursor.lnum);
     if (cap->count0 > 0 && cap->count0 <= 100) {
       coladvance((colnr_T)(i * cap->count0 / 100));
     } else {
@@ -5570,7 +5551,7 @@ static void nv_g_cmd(cmdarg_T *cap)
 
   // "gs": Goto sleep.
   case 's':
-    do_sleep(cap->count1 * 1000L);
+    do_sleep(cap->count1 * 1000);
     break;
 
   // "ga": Display the ascii value of the character under the
@@ -5625,7 +5606,7 @@ static void nv_g_cmd(cmdarg_T *cap)
   // "gD": idem, but in the current file.
   case 'd':
   case 'D':
-    nv_gd(oap, cap->nchar, (int)cap->count0);
+    nv_gd(oap, cap->nchar, cap->count0);
     break;
 
   // g<*Mouse> : <C-*mouse>
@@ -5681,12 +5662,12 @@ static void nv_g_cmd(cmdarg_T *cap)
 
   case 't':
     if (!checkclearop(oap)) {
-      goto_tabpage((int)cap->count0);
+      goto_tabpage(cap->count0);
     }
     break;
   case 'T':
     if (!checkclearop(oap)) {
-      goto_tabpage(-(int)cap->count1);
+      goto_tabpage(-cap->count1);
     }
     break;
 
@@ -5726,10 +5707,10 @@ static void n_opencmd(cmdarg_T *cap)
     (void)hasFolding(curwin->w_cursor.lnum,
                      NULL, &curwin->w_cursor.lnum);
   }
-  if (u_save((linenr_T)(curwin->w_cursor.lnum -
-                        (cap->cmdchar == 'O' ? 1 : 0)),
-             (linenr_T)(curwin->w_cursor.lnum +
-                        (cap->cmdchar == 'o' ? 1 : 0)))
+  // trigger TextChangedI for the 'o/O' command
+  curbuf->b_last_changedtick_i = buf_get_changedtick(curbuf);
+  if (u_save(curwin->w_cursor.lnum - (cap->cmdchar == 'O' ? 1 : 0),
+             curwin->w_cursor.lnum + (cap->cmdchar == 'o' ? 1 : 0))
       && open_line(cap->cmdchar == 'O' ? BACKWARD : FORWARD,
                    has_format_option(FO_OPEN_COMS) ? OPENLINE_DO_COM : 0,
                    0, NULL)) {
@@ -5760,10 +5741,9 @@ static void nv_dot(cmdarg_T *cap)
 static void nv_redo_or_register(cmdarg_T *cap)
 {
   if (VIsual_select && VIsual_active) {
-    int reg;
     // Get register name
     no_mapping++;
-    reg = plain_vgetc();
+    int reg = plain_vgetc();
     LANGMAP_ADJUST(reg, true);
     no_mapping--;
 
@@ -5780,7 +5760,7 @@ static void nv_redo_or_register(cmdarg_T *cap)
     return;
   }
 
-  u_redo((int)cap->count1);
+  u_redo(cap->count1);
   curwin->w_set_curswant = true;
 }
 
@@ -5823,9 +5803,7 @@ static void nv_tilde(cmdarg_T *cap)
 /// The actual work is done by do_pending_operator().
 static void nv_operator(cmdarg_T *cap)
 {
-  int op_type;
-
-  op_type = get_op_type(cap->cmdchar, cap->nchar);
+  int op_type = get_op_type(cap->cmdchar, cap->nchar);
 
   if (bt_prompt(curbuf) && op_is_change(op_type)
       && !prompt_curpos_editable()) {
@@ -5872,7 +5850,7 @@ static void set_op_var(int optype)
 static void nv_lineop(cmdarg_T *cap)
 {
   cap->oap->motion_type = kMTLineWise;
-  if (cursor_down(cap->count1 - 1L, cap->oap->op_type == OP_NOP) == false) {
+  if (cursor_down(cap->count1 - 1, cap->oap->op_type == OP_NOP) == false) {
     clearopbeep(cap->oap);
   } else if ((cap->oap->op_type == OP_DELETE
               // only with linewise motions
@@ -6042,9 +6020,8 @@ static void adjust_for_sel(cmdarg_T *cap)
 /// @return  true when backed up to the previous line.
 bool unadjust_for_sel(void)
 {
-  pos_T *pp;
-
   if (*p_sel == 'e' && !equalpos(VIsual, curwin->w_cursor)) {
+    pos_T *pp;
     if (lt(VIsual, curwin->w_cursor)) {
       pp = &curwin->w_cursor;
     } else {
@@ -6086,17 +6063,17 @@ static void nv_goto(cmdarg_T *cap)
   if (cap->arg) {
     lnum = curbuf->b_ml.ml_line_count;
   } else {
-    lnum = 1L;
+    lnum = 1;
   }
   cap->oap->motion_type = kMTLineWise;
   setpcmark();
 
   // When a count is given, use it instead of the default lnum
   if (cap->count0 != 0) {
-    lnum = (linenr_T)cap->count0;
+    lnum = cap->count0;
   }
-  if (lnum < 1L) {
-    lnum = 1L;
+  if (lnum < 1) {
+    lnum = 1;
   } else if (lnum > curbuf->b_ml.ml_line_count) {
     lnum = curbuf->b_ml.ml_line_count;
   }
@@ -6132,20 +6109,18 @@ static void nv_normal(cmdarg_T *cap)
 /// Don't even beep if we are canceling a command.
 static void nv_esc(cmdarg_T *cap)
 {
-  int no_reason;
-
-  no_reason = (cap->oap->op_type == OP_NOP
-               && cap->opcount == 0
-               && cap->count0 == 0
-               && cap->oap->regname == 0);
+  int no_reason = (cap->oap->op_type == OP_NOP
+                   && cap->opcount == 0
+                   && cap->count0 == 0
+                   && cap->oap->regname == 0);
 
   if (cap->arg) {               // true for CTRL-C
     if (restart_edit == 0 && cmdwin_type == 0 && !VIsual_active && no_reason) {
       if (anyBufIsChanged()) {
         msg(_("Type  :qa!  and press <Enter> to abandon all changes"
-              " and exit Nvim"));
+              " and exit Nvim"), 0);
       } else {
-        msg(_("Type  :qa  and press <Enter> to exit Nvim"));
+        msg(_("Type  :qa  and press <Enter> to exit Nvim"), 0);
       }
     }
 
@@ -6270,6 +6245,11 @@ static void invoke_edit(cmdarg_T *cap, int repl, int cmd, int startln)
   // Always reset "restart_edit", this is not a restarted edit.
   restart_edit = 0;
 
+  // Reset Changedtick_i, so that TextChangedI will only be triggered for stuff
+  // from insert mode, for 'o/O' this has already been done in n_opencmd
+  if (cap->cmdchar != 'O' && cap->cmdchar != 'o') {
+    curbuf->b_last_changedtick_i = buf_get_changedtick(curbuf);
+  }
   if (edit(cmd, startln, cap->count1)) {
     cap->retval |= CA_COMMAND_BUSY;
   }
@@ -6284,7 +6264,6 @@ static void nv_object(cmdarg_T *cap)
 {
   bool flag;
   bool include;
-  char *mps_save;
 
   if (cap->cmdchar == 'i') {
     include = false;        // "ix" = inner object: exclude white space
@@ -6292,7 +6271,7 @@ static void nv_object(cmdarg_T *cap)
     include = true;         // "ax" = an object: include white space
   }
   // Make sure (), [], {} and <> are in 'matchpairs'
-  mps_save = curbuf->b_p_mps;
+  char *mps_save = curbuf->b_p_mps;
   curbuf->b_p_mps = "(:),{:},[:],<:>";
 
   switch (cap->nchar) {
@@ -6372,6 +6351,10 @@ static void nv_record(cmdarg_T *cap)
   }
 
   if (cap->nchar == ':' || cap->nchar == '/' || cap->nchar == '?') {
+    if (cmdwin_type != 0) {
+      emsg(_(e_cmdline_window_already_open));
+      return;
+    }
     stuffcharReadbuff(cap->nchar);
     stuffcharReadbuff(K_CMDWIN);
   } else {
@@ -6411,7 +6394,7 @@ static void nv_halfpage(cmdarg_T *cap)
           && curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count)) {
     clearopbeep(cap->oap);
   } else if (!checkclearop(cap->oap)) {
-    halfpage(cap->cmdchar == Ctrl_D, (linenr_T)cap->count0);
+    halfpage(cap->cmdchar == Ctrl_D, cap->count0);
   }
 }
 
@@ -6456,7 +6439,6 @@ static void nv_put(cmdarg_T *cap)
 /// @param fix_indent  true for "[p", "[P", "]p" and "]P".
 static void nv_put_opt(cmdarg_T *cap, bool fix_indent)
 {
-  int regname = 0;
   yankreg_T *savereg = NULL;
   bool empty = false;
   bool was_visual = false;
@@ -6482,7 +6464,7 @@ static void nv_put_opt(cmdarg_T *cap, bool fix_indent)
 
   if (fix_indent) {
     dir = (cap->cmdchar == ']' && cap->nchar == 'p')
-      ? FORWARD : BACKWARD;
+          ? FORWARD : BACKWARD;
     flags |= PUT_FIXINDENT;
   } else {
     dir = (cap->cmdchar == 'P'
@@ -6502,7 +6484,7 @@ static void nv_put_opt(cmdarg_T *cap, bool fix_indent)
     // Need to save and restore the registers that the delete
     // overwrites if the old contents is being put.
     was_visual = true;
-    regname = cap->oap->regname;
+    int regname = cap->oap->regname;
     bool keep_registers = cap->cmdchar == 'P';
     // '+' and '*' could be the same selection
     bool clipoverwrite = (regname == '+' || regname == '*') && (cb_flags & CB_UNNAMEDMASK);