Merge pull request #10171 from blueyed/vim-8.1.1318

vim-patch:8.1.1318: code for text changes is in a "misc" file

22 files changed, 1830 insertions, 1846 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index c6f82e9d85..41d7d8ba6b 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -15,6 +15,7 @@
 #include "nvim/lua/executor.h"
 #include "nvim/vim.h"
 #include "nvim/buffer.h"
+#include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/getchar.h"
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 89f1e33a86..a545112360 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -32,6 +32,7 @@
 #include "nvim/channel.h"
 #include "nvim/vim.h"
 #include "nvim/buffer.h"
+#include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/diff.h"
diff --git a/src/nvim/change.c b/src/nvim/change.c
new file mode 100644
index 0000000000..2363578139
--- /dev/null
+++ b/src/nvim/change.c
@@ -0,0 +1,1798 @@
+// 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
+
+/// change.c: functions related to changing text
+
+#include "nvim/assert.h"
+#include "nvim/buffer.h"
+#include "nvim/buffer_updates.h"
+#include "nvim/change.h"
+#include "nvim/charset.h"
+#include "nvim/cursor.h"
+#include "nvim/diff.h"
+#include "nvim/edit.h"
+#include "nvim/eval.h"
+#include "nvim/fileio.h"
+#include "nvim/fold.h"
+#include "nvim/indent.h"
+#include "nvim/indent_c.h"
+#include "nvim/mark.h"
+#include "nvim/memline.h"
+#include "nvim/misc1.h"
+#include "nvim/move.h"
+#include "nvim/option.h"
+#include "nvim/screen.h"
+#include "nvim/search.h"
+#include "nvim/state.h"
+#include "nvim/ui.h"
+#include "nvim/undo.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "change.c.generated.h"
+#endif
+
+/// If the file is readonly, give a warning message with the first change.
+/// Don't do this for autocommands.
+/// Doesn't use emsg(), because it flushes the macro buffer.
+/// If we have undone all changes b_changed will be false, but "b_did_warn"
+/// will be true.
+/// "col" is the column for the message; non-zero when in insert mode and
+/// 'showmode' is on.
+/// Careful: may trigger autocommands that reload the buffer.
+void change_warning(int col)
+{
+  static char *w_readonly = N_("W10: Warning: Changing a readonly file");
+
+  if (curbuf->b_did_warn == false
+      && curbufIsChanged() == 0
+      && !autocmd_busy
+      && curbuf->b_p_ro) {
+    curbuf_lock++;
+    apply_autocmds(EVENT_FILECHANGEDRO, NULL, NULL, false, curbuf);
+    curbuf_lock--;
+    if (!curbuf->b_p_ro) {
+        return;
+    }
+    // Do what msg() does, but with a column offset if the warning should
+    // be after the mode message.
+    msg_start();
+    if (msg_row == Rows - 1) {
+        msg_col = col;
+    }
+    msg_source(HL_ATTR(HLF_W));
+    msg_ext_set_kind("wmsg");
+    MSG_PUTS_ATTR(_(w_readonly), HL_ATTR(HLF_W) | MSG_HIST);
+    set_vim_var_string(VV_WARNINGMSG, _(w_readonly), -1);
+    msg_clr_eos();
+    (void)msg_end();
+    if (msg_silent == 0 && !silent_mode && ui_active()) {
+      ui_flush();
+      os_delay(1000L, true);  // give the user time to think about it
+    }
+    curbuf->b_did_warn = true;
+    redraw_cmdline = false;  // don't redraw and erase the message
+    if (msg_row < Rows - 1) {
+        showmode();
+    }
+  }
+}
+
+/// Call this function when something in the current buffer is changed.
+///
+/// Most often called through changed_bytes() and changed_lines(), which also
+/// mark the area of the display to be redrawn.
+///
+/// Careful: may trigger autocommands that reload the buffer.
+void changed(void)
+{
+  if (!curbuf->b_changed) {
+    int save_msg_scroll = msg_scroll;
+
+    // Give a warning about changing a read-only file.  This may also
+    // check-out the file, thus change "curbuf"!
+    change_warning(0);
+
+    // Create a swap file if that is wanted.
+    // Don't do this for "nofile" and "nowrite" buffer types.
+    if (curbuf->b_may_swap
+        && !bt_dontwrite(curbuf)
+        ) {
+      int save_need_wait_return = need_wait_return;
+
+      need_wait_return = false;
+      ml_open_file(curbuf);
+
+      // The ml_open_file() can cause an ATTENTION message.
+      // Wait two seconds, to make sure the user reads this unexpected
+      // message.  Since we could be anywhere, call wait_return() now,
+      // and don't let the emsg() set msg_scroll.
+      if (need_wait_return && emsg_silent == 0) {
+        ui_flush();
+        os_delay(2000L, true);
+        wait_return(true);
+        msg_scroll = save_msg_scroll;
+      } else {
+        need_wait_return = save_need_wait_return;
+      }
+    }
+    changed_internal();
+  }
+  buf_inc_changedtick(curbuf);
+
+  // If a pattern is highlighted, the position may now be invalid.
+  highlight_match = false;
+}
+
+/// Internal part of changed(), no user interaction.
+/// Also used for recovery.
+void changed_internal(void)
+{
+  curbuf->b_changed = true;
+  ml_setflags(curbuf);
+  check_status(curbuf);
+  redraw_tabline = true;
+  need_maketitle = true;  // set window title later
+}
+
+/// Common code for when a change was made.
+/// See changed_lines() for the arguments.
+/// Careful: may trigger autocommands that reload the buffer.
+static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume,
+                           long xtra)
+{
+  int i;
+  int cols;
+  pos_T       *p;
+  int add;
+
+  // mark the buffer as modified
+  changed();
+
+  if (curwin->w_p_diff && diff_internal()) {
+    curtab->tp_diff_update = true;
+  }
+
+  // set the '. mark
+  if (!cmdmod.keepjumps) {
+    RESET_FMARK(&curbuf->b_last_change, ((pos_T) { lnum, col, 0 }), 0);
+
+    // Create a new entry if a new undo-able change was started or we
+    // don't have an entry yet.
+    if (curbuf->b_new_change || curbuf->b_changelistlen == 0) {
+      if (curbuf->b_changelistlen == 0) {
+          add = true;
+      } else {
+        // Don't create a new entry when the line number is the same
+        // as the last one and the column is not too far away.  Avoids
+        // creating many entries for typing "xxxxx".
+        p = &curbuf->b_changelist[curbuf->b_changelistlen - 1].mark;
+        if (p->lnum != lnum) {
+            add = true;
+        } else {
+          cols = comp_textwidth(false);
+          if (cols == 0) {
+              cols = 79;
+          }
+          add = (p->col + cols < col || col + cols < p->col);
+        }
+      }
+      if (add) {
+        // This is the first of a new sequence of undo-able changes
+        // and it's at some distance of the last change.  Use a new
+        // position in the changelist.
+        curbuf->b_new_change = false;
+
+        if (curbuf->b_changelistlen == JUMPLISTSIZE) {
+          // changelist is full: remove oldest entry
+          curbuf->b_changelistlen = JUMPLISTSIZE - 1;
+          memmove(curbuf->b_changelist, curbuf->b_changelist + 1,
+                  sizeof(curbuf->b_changelist[0]) * (JUMPLISTSIZE - 1));
+          FOR_ALL_TAB_WINDOWS(tp, wp) {
+            // Correct position in changelist for other windows on
+            // this buffer.
+            if (wp->w_buffer == curbuf && wp->w_changelistidx > 0) {
+              wp->w_changelistidx--;
+            }
+          }
+        }
+        FOR_ALL_TAB_WINDOWS(tp, wp) {
+          // For other windows, if the position in the changelist is
+          // at the end it stays at the end.
+          if (wp->w_buffer == curbuf
+              && wp->w_changelistidx == curbuf->b_changelistlen) {
+            wp->w_changelistidx++;
+          }
+        }
+        curbuf->b_changelistlen++;
+      }
+    }
+    curbuf->b_changelist[curbuf->b_changelistlen - 1] =
+      curbuf->b_last_change;
+    // The current window is always after the last change, so that "g,"
+    // takes you back to it.
+    curwin->w_changelistidx = curbuf->b_changelistlen;
+  }
+
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    if (wp->w_buffer == curbuf) {
+      // Mark this window to be redrawn later.
+      if (wp->w_redr_type < VALID) {
+          wp->w_redr_type = VALID;
+      }
+
+      // Check if a change in the buffer has invalidated the cached
+      // values for the cursor.
+      // Update the folds for this window.  Can't postpone this, because
+      // a following operator might work on the whole fold: ">>dd".
+      foldUpdate(wp, lnum, lnume + xtra - 1);
+
+      // The change may cause lines above or below the change to become
+      // included in a fold.  Set lnum/lnume to the first/last line that
+      // might be displayed differently.
+      // Set w_cline_folded here as an efficient way to update it when
+      // inserting lines just above a closed fold. */
+      bool folded = hasFoldingWin(wp, lnum, &lnum, NULL, false, NULL);
+      if (wp->w_cursor.lnum == lnum) {
+          wp->w_cline_folded = folded;
+      }
+      folded = hasFoldingWin(wp, lnume, NULL, &lnume, false, NULL);
+      if (wp->w_cursor.lnum == lnume) {
+          wp->w_cline_folded = folded;
+      }
+
+      // If the changed line is in a range of previously folded lines,
+      // compare with the first line in that range.
+      if (wp->w_cursor.lnum <= lnum) {
+        i = find_wl_entry(wp, lnum);
+        if (i >= 0 && wp->w_cursor.lnum > wp->w_lines[i].wl_lnum) {
+            changed_line_abv_curs_win(wp);
+        }
+      }
+
+      if (wp->w_cursor.lnum > lnum) {
+          changed_line_abv_curs_win(wp);
+      } else if (wp->w_cursor.lnum == lnum && wp->w_cursor.col >= col) {
+          changed_cline_bef_curs_win(wp);
+      }
+      if (wp->w_botline >= lnum) {
+        // Assume that botline doesn't change (inserted lines make
+        // other lines scroll down below botline).
+        approximate_botline_win(wp);
+      }
+
+      // Check if any w_lines[] entries have become invalid.
+      // For entries below the change: Correct the lnums for
+      // inserted/deleted lines.  Makes it possible to stop displaying
+      // after the change.
+      for (i = 0; i < wp->w_lines_valid; i++) {
+        if (wp->w_lines[i].wl_valid) {
+          if (wp->w_lines[i].wl_lnum >= lnum) {
+            if (wp->w_lines[i].wl_lnum < lnume) {
+              // line included in change
+              wp->w_lines[i].wl_valid = false;
+            } else if (xtra != 0) {
+              // line below change
+              wp->w_lines[i].wl_lnum += xtra;
+              wp->w_lines[i].wl_lastlnum += xtra;
+            }
+          } else if (wp->w_lines[i].wl_lastlnum >= lnum) {
+            // change somewhere inside this range of folded lines,
+            // may need to be redrawn
+            wp->w_lines[i].wl_valid = false;
+          }
+        }
+      }
+
+      // Take care of side effects for setting w_topline when folds have
+      // changed.  Esp. when the buffer was changed in another window.
+      if (hasAnyFolding(wp)) {
+        set_topline(wp, wp->w_topline);
+      }
+
+      // relative numbering may require updating more
+      if (wp->w_p_rnu) {
+        redraw_win_later(wp, SOME_VALID);
+      }
+    }
+  }
+
+  // Call update_screen() later, which checks out what needs to be redrawn,
+  // since it notices b_mod_set and then uses b_mod_*.
+  if (must_redraw < VALID) {
+    must_redraw = VALID;
+  }
+
+  // when the cursor line is changed always trigger CursorMoved
+  if (lnum <= curwin->w_cursor.lnum
+      && lnume + (xtra < 0 ? -xtra : xtra) > curwin->w_cursor.lnum) {
+    curwin->w_last_cursormoved.lnum = 0;
+  }
+}
+
+static void changedOneline(buf_T *buf, linenr_T lnum)
+{
+  if (buf->b_mod_set) {
+    // find the maximum area that must be redisplayed
+    if (lnum < buf->b_mod_top) {
+        buf->b_mod_top = lnum;
+    } else if (lnum >= buf->b_mod_bot) {
+        buf->b_mod_bot = lnum + 1;
+    }
+  } else {
+    // set the area that must be redisplayed to one line
+    buf->b_mod_set = true;
+    buf->b_mod_top = lnum;
+    buf->b_mod_bot = lnum + 1;
+    buf->b_mod_xlines = 0;
+  }
+}
+
+/// Changed bytes within a single line for the current buffer.
+/// - marks the windows on this buffer to be redisplayed
+/// - marks the buffer changed by calling changed()
+/// - invalidates cached values
+/// Careful: may trigger autocommands that reload the buffer.
+void changed_bytes(linenr_T lnum, colnr_T col)
+{
+  changedOneline(curbuf, lnum);
+  changed_common(lnum, col, lnum + 1, 0L);
+  // notify any channels that are watching
+  buf_updates_send_changes(curbuf, lnum, 1, 1, true);
+
+  // Diff highlighting in other diff windows may need to be updated too.
+  if (curwin->w_p_diff) {
+    linenr_T wlnum;
+
+    FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+      if (wp->w_p_diff && wp != curwin) {
+        redraw_win_later(wp, VALID);
+        wlnum = diff_lnum_win(lnum, wp);
+        if (wlnum > 0) {
+            changedOneline(wp->w_buffer, wlnum);
+        }
+      }
+    }
+  }
+}
+
+/// Appended "count" lines below line "lnum" in the current buffer.
+/// Must be called AFTER the change and after mark_adjust().
+/// Takes care of marking the buffer to be redrawn and sets the changed flag.
+void appended_lines(linenr_T lnum, long count)
+{
+  changed_lines(lnum + 1, 0, lnum + 1, count, true);
+}
+
+/// Like appended_lines(), but adjust marks first.
+void appended_lines_mark(linenr_T lnum, long count)
+{
+  // Skip mark_adjust when adding a line after the last one, there can't
+  // be marks there. But it's still needed in diff mode.
+  if (lnum + count < curbuf->b_ml.ml_line_count || curwin->w_p_diff) {
+    mark_adjust(lnum + 1, (linenr_T)MAXLNUM, count, 0L, false);
+  }
+  changed_lines(lnum + 1, 0, lnum + 1, count, true);
+}
+
+/// Deleted "count" lines at line "lnum" in the current buffer.
+/// Must be called AFTER the change and after mark_adjust().
+/// Takes care of marking the buffer to be redrawn and sets the changed flag.
+void deleted_lines(linenr_T lnum, long count)
+{
+  changed_lines(lnum, 0, lnum + count, -count, true);
+}
+
+/// Like deleted_lines(), but adjust marks first.
+/// Make sure the cursor is on a valid line before calling, a GUI callback may
+/// be triggered to display the cursor.
+void deleted_lines_mark(linenr_T lnum, long count)
+{
+  mark_adjust(lnum, (linenr_T)(lnum + count - 1), (long)MAXLNUM, -count, false);
+  changed_lines(lnum, 0, lnum + count, -count, true);
+}
+
+/// Marks the area to be redrawn after a change.
+///
+/// @param buf the buffer where lines were changed
+/// @param lnum first line with change
+/// @param lnume line below last changed line
+/// @param xtra number of extra lines (negative when deleting)
+void changed_lines_buf(buf_T *buf, linenr_T lnum, linenr_T lnume, long xtra)
+{
+  if (buf->b_mod_set) {
+    // find the maximum area that must be redisplayed
+    if (lnum < buf->b_mod_top) {
+      buf->b_mod_top = lnum;
+    }
+    if (lnum < buf->b_mod_bot) {
+      // adjust old bot position for xtra lines
+      buf->b_mod_bot += xtra;
+      if (buf->b_mod_bot < lnum) {
+        buf->b_mod_bot = lnum;
+      }
+    }
+    if (lnume + xtra > buf->b_mod_bot) {
+      buf->b_mod_bot = lnume + xtra;
+    }
+    buf->b_mod_xlines += xtra;
+  } else {
+    // set the area that must be redisplayed
+    buf->b_mod_set = true;
+    buf->b_mod_top = lnum;
+    buf->b_mod_bot = lnume + xtra;
+    buf->b_mod_xlines = xtra;
+  }
+}
+
+/// Changed lines for the current buffer.
+/// Must be called AFTER the change and after mark_adjust().
+/// - mark the buffer changed by calling changed()
+/// - mark the windows on this buffer to be redisplayed
+/// - invalidate cached values
+/// "lnum" is the first line that needs displaying, "lnume" the first line
+/// below the changed lines (BEFORE the change).
+/// When only inserting lines, "lnum" and "lnume" are equal.
+/// Takes care of calling changed() and updating b_mod_*.
+/// Careful: may trigger autocommands that reload the buffer.
+void
+changed_lines(
+    linenr_T lnum,        // first line with change
+    colnr_T col,          // column in first line with change
+    linenr_T lnume,       // line below last changed line
+    long xtra,            // number of extra lines (negative when deleting)
+    bool do_buf_event  // some callers like undo/redo call changed_lines()
+                       // and then increment changedtick *again*. This flag
+                       // allows these callers to send the nvim_buf_lines_event
+                       // events after they're done modifying changedtick.
+)
+{
+  changed_lines_buf(curbuf, lnum, lnume, xtra);
+
+  if (xtra == 0 && curwin->w_p_diff && !diff_internal()) {
+    // When the number of lines doesn't change then mark_adjust() isn't
+    // called and other diff buffers still need to be marked for
+    // displaying.
+    linenr_T wlnum;
+
+    FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+      if (wp->w_p_diff && wp != curwin) {
+        redraw_win_later(wp, VALID);
+        wlnum = diff_lnum_win(lnum, wp);
+        if (wlnum > 0) {
+          changed_lines_buf(wp->w_buffer, wlnum,
+                            lnume - lnum + wlnum, 0L);
+        }
+      }
+    }
+  }
+
+  changed_common(lnum, col, lnume, xtra);
+
+  if (do_buf_event) {
+    int64_t num_added = (int64_t)(lnume + xtra - lnum);
+    int64_t num_removed = lnume - lnum;
+    buf_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
+  }
+}
+
+/// Called when the changed flag must be reset for buffer "buf".
+/// When "ff" is true also reset 'fileformat'.
+void unchanged(buf_T *buf, int ff)
+{
+  if (buf->b_changed || (ff && file_ff_differs(buf, false))) {
+    buf->b_changed = false;
+    ml_setflags(buf);
+    if (ff) {
+      save_file_ff(buf);
+    }
+    check_status(buf);
+    redraw_tabline = true;
+    need_maketitle = true;  // set window title later
+  }
+  buf_inc_changedtick(buf);
+}
+
+/// Insert string "p" at the cursor position.  Stops at a NUL byte.
+/// Handles Replace mode and multi-byte characters.
+void ins_bytes(char_u *p)
+{
+  ins_bytes_len(p, STRLEN(p));
+}
+
+/// Insert string "p" with length "len" at the cursor position.
+/// Handles Replace mode and multi-byte characters.
+void ins_bytes_len(char_u *p, size_t len)
+{
+  size_t n;
+  for (size_t i = 0; i < len; i += n) {
+    if (enc_utf8) {
+      // avoid reading past p[len]
+      n = (size_t)utfc_ptr2len_len(p + i, (int)(len - i));
+    } else {
+      n = (size_t)(*mb_ptr2len)(p + i);
+    }
+    ins_char_bytes(p + i, n);
+  }
+}
+
+/// Insert or replace a single character at the cursor position.
+/// When in REPLACE or VREPLACE mode, replace any existing character.
+/// Caller must have prepared for undo.
+/// For multi-byte characters we get the whole character, the caller must
+/// convert bytes to a character.
+void ins_char(int c)
+{
+  char_u buf[MB_MAXBYTES + 1];
+  size_t n = (size_t)utf_char2bytes(c, buf);
+
+  // When "c" is 0x100, 0x200, etc. we don't want to insert a NUL byte.
+  // Happens for CTRL-Vu9900.
+  if (buf[0] == 0) {
+    buf[0] = '\n';
+  }
+  ins_char_bytes(buf, n);
+}
+
+void ins_char_bytes(char_u *buf, size_t charlen)
+{
+  // Break tabs if needed.
+  if (virtual_active() && curwin->w_cursor.coladd > 0) {
+    coladvance_force(getviscol());
+  }
+
+  size_t col = (size_t)curwin->w_cursor.col;
+  linenr_T lnum = curwin->w_cursor.lnum;
+  char_u *oldp = ml_get(lnum);
+  size_t linelen = STRLEN(oldp) + 1;  // length of old line including NUL
+
+  // The lengths default to the values for when not replacing.
+  size_t oldlen = 0;        // nr of bytes inserted
+  size_t newlen = charlen;  // nr of bytes deleted (0 when not replacing)
+
+  if (State & REPLACE_FLAG) {
+    if (State & VREPLACE_FLAG) {
+      // Disable 'list' temporarily, unless 'cpo' contains the 'L' flag.
+      // Returns the old value of list, so when finished,
+      // curwin->w_p_list should be set back to this.
+      int old_list = curwin->w_p_list;
+      if (old_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL) {
+        curwin->w_p_list = false;
+      }
+      // In virtual replace mode each character may replace one or more
+      // characters (zero if it's a TAB).  Count the number of bytes to
+      // be deleted to make room for the new character, counting screen
+      // cells.  May result in adding spaces to fill a gap.
+      colnr_T vcol;
+      getvcol(curwin, &curwin->w_cursor, NULL, &vcol, NULL);
+      colnr_T new_vcol = vcol + chartabsize(buf, vcol);
+      while (oldp[col + oldlen] != NUL && vcol < new_vcol) {
+        vcol += chartabsize(oldp + col + oldlen, vcol);
+        // Don't need to remove a TAB that takes us to the right
+        // position.
+        if (vcol > new_vcol && oldp[col + oldlen] == TAB) {
+          break;
+        }
+        oldlen += (size_t)(*mb_ptr2len)(oldp + col + oldlen);
+        // Deleted a bit too much, insert spaces.
+        if (vcol > new_vcol) {
+          newlen += (size_t)(vcol - new_vcol);
+        }
+      }
+      curwin->w_p_list = old_list;
+    } else if (oldp[col] != NUL)  {
+      // normal replace
+      oldlen = (size_t)(*mb_ptr2len)(oldp + col);
+    }
+
+
+    // Push the replaced bytes onto the replace stack, so that they can be
+    // put back when BS is used.  The bytes of a multi-byte character are
+    // done the other way around, so that the first byte is popped off
+    // first (it tells the byte length of the character).
+    replace_push(NUL);
+    for (size_t i = 0; i < oldlen; i++) {
+      i += (size_t)replace_push_mb(oldp + col + i) - 1;
+    }
+  }
+
+  char_u *newp = xmalloc((size_t)(linelen + newlen - oldlen));
+
+  // Copy bytes before the cursor.
+  if (col > 0) {
+    memmove(newp, oldp, (size_t)col);
+  }
+
+  // Copy bytes after the changed character(s).
+  char_u *p = newp + col;
+  if (linelen > col + oldlen) {
+    memmove(p + newlen, oldp + col + oldlen,
+            (size_t)(linelen - col - oldlen));
+  }
+
+  // Insert or overwrite the new character.
+  memmove(p, buf, charlen);
+
+  // Fill with spaces when necessary.
+  for (size_t i = charlen; i < newlen; i++) {
+    p[i] = ' ';
+  }
+
+  // Replace the line in the buffer.
+  ml_replace(lnum, newp, false);
+
+  // mark the buffer as changed and prepare for displaying
+  changed_bytes(lnum, (colnr_T)col);
+
+  // If we're in Insert or Replace mode and 'showmatch' is set, then briefly
+  // show the match for right parens and braces.
+  if (p_sm && (State & INSERT)
+      && msg_silent == 0
+      && !ins_compl_active()
+      ) {
+    showmatch(utf_ptr2char(buf));
+  }
+
+  if (!p_ri || (State & REPLACE_FLAG)) {
+    // Normal insert: move cursor right
+    curwin->w_cursor.col += (int)charlen;
+  }
+  // TODO(Bram): should try to update w_row here, to avoid recomputing it later.
+}
+
+/// Insert a string at the cursor position.
+/// Note: Does NOT handle Replace mode.
+/// Caller must have prepared for undo.
+void ins_str(char_u *s)
+{
+  char_u      *oldp, *newp;
+  int newlen = (int)STRLEN(s);
+  int oldlen;
+  colnr_T col;
+  linenr_T lnum = curwin->w_cursor.lnum;
+
+  if (virtual_active() && curwin->w_cursor.coladd > 0) {
+    coladvance_force(getviscol());
+  }
+
+  col = curwin->w_cursor.col;
+  oldp = ml_get(lnum);
+  oldlen = (int)STRLEN(oldp);
+
+  newp = (char_u *)xmalloc((size_t)oldlen + (size_t)newlen + 1);
+  if (col > 0) {
+    memmove(newp, oldp, (size_t)col);
+  }
+  memmove(newp + col, s, (size_t)newlen);
+  int bytes = oldlen - col + 1;
+  assert(bytes >= 0);
+  memmove(newp + col + newlen, oldp + col, (size_t)bytes);
+  ml_replace(lnum, newp, false);
+  changed_bytes(lnum, col);
+  curwin->w_cursor.col += newlen;
+}
+
+// Delete one character under the cursor.
+// If "fixpos" is true, don't leave the cursor on the NUL after the line.
+// Caller must have prepared for undo.
+//
+// return FAIL for failure, OK otherwise
+int del_char(bool fixpos)
+{
+  // Make sure the cursor is at the start of a character.
+  mb_adjust_cursor();
+  if (*get_cursor_pos_ptr() == NUL) {
+    return FAIL;
+  }
+  return del_chars(1L, fixpos);
+}
+
+/// Like del_bytes(), but delete characters instead of bytes.
+int del_chars(long count, int fixpos)
+{
+  int bytes = 0;
+  long i;
+  char_u      *p;
+  int l;
+
+  p = get_cursor_pos_ptr();
+  for (i = 0; i < count && *p != NUL; i++) {
+    l = (*mb_ptr2len)(p);
+    bytes += l;
+    p += l;
+  }
+  return del_bytes(bytes, fixpos, true);
+}
+
+/// Delete "count" bytes under the cursor.
+/// If "fixpos" is true, don't leave the cursor on the NUL after the line.
+/// Caller must have prepared for undo.
+///
+/// @param  count           number of bytes to be deleted
+/// @param  fixpos_arg      leave the cursor on the NUL after the line
+/// @param  use_delcombine  'delcombine' option applies
+///
+/// @return FAIL for failure, OK otherwise
+int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
+{
+  linenr_T lnum = curwin->w_cursor.lnum;
+  colnr_T col = curwin->w_cursor.col;
+  bool fixpos = fixpos_arg;
+  char_u *oldp = ml_get(lnum);
+  colnr_T oldlen = (colnr_T)STRLEN(oldp);
+
+  // Can't do anything when the cursor is on the NUL after the line.
+  if (col >= oldlen) {
+    return FAIL;
+  }
+  // If "count" is zero there is nothing to do.
+  if (count == 0) {
+    return OK;
+  }
+  // If "count" is negative the caller must be doing something wrong.
+  if (count < 1) {
+    IEMSGN("E950: Invalid count for del_bytes(): %ld", count);
+    return FAIL;
+  }
+
+  // If 'delcombine' is set and deleting (less than) one character, only
+  // delete the last combining character.
+  if (p_deco && use_delcombine && enc_utf8
+      && utfc_ptr2len(oldp + col) >= count) {
+    int cc[MAX_MCO];
+    int n;
+
+    (void)utfc_ptr2char(oldp + col, cc);
+    if (cc[0] != NUL) {
+      // Find the last composing char, there can be several.
+      n = col;
+      do {
+        col = n;
+        count = utf_ptr2len(oldp + n);
+        n += count;
+      } while (UTF_COMPOSINGLIKE(oldp + col, oldp + n));
+      fixpos = false;
+    }
+  }
+
+  // When count is too big, reduce it.
+  int movelen = oldlen - col - count + 1;  // includes trailing NUL
+  if (movelen <= 1) {
+    // If we just took off the last character of a non-blank line, and
+    // fixpos is TRUE, we don't want to end up positioned at the NUL,
+    // unless "restart_edit" is set or 'virtualedit' contains "onemore".
+    if (col > 0 && fixpos && restart_edit == 0
+        && (ve_flags & VE_ONEMORE) == 0
+        ) {
+      curwin->w_cursor.col--;
+      curwin->w_cursor.coladd = 0;
+      curwin->w_cursor.col -= utf_head_off(oldp, oldp + curwin->w_cursor.col);
+    }
+    count = oldlen - col;
+    movelen = 1;
+  }
+
+  // If the old line has been allocated the deletion can be done in the
+  // existing line. Otherwise a new line has to be allocated.
+  bool was_alloced = ml_line_alloced();     // check if oldp was allocated
+  char_u *newp;
+  if (was_alloced) {
+    ml_add_deleted_len(curbuf->b_ml.ml_line_ptr, oldlen);
+    newp = oldp;                            // use same allocated memory
+  } else {                                  // need to allocate a new line
+    newp = xmalloc((size_t)(oldlen + 1 - count));
+    memmove(newp, oldp, (size_t)col);
+  }
+  memmove(newp + col, oldp + col + count, (size_t)movelen);
+  if (!was_alloced) {
+    ml_replace(lnum, newp, false);
+  }
+
+  // mark the buffer as changed and prepare for displaying
+  changed_bytes(lnum, curwin->w_cursor.col);
+
+  return OK;
+}
+
+/// Copy the indent from ptr to the current line (and fill to size).
+/// Leaves the cursor on the first non-blank in the line.
+/// @return true if the line was changed.
+int copy_indent(int size, char_u *src)
+{
+  char_u *p = NULL;
+  char_u *line = NULL;
+  char_u *s;
+  int todo;
+  int ind_len;
+  int line_len = 0;
+  int tab_pad;
+  int ind_done;
+  int round;
+
+  // Round 1: compute the number of characters needed for the indent
+  // Round 2: copy the characters.
+  for (round = 1; round <= 2; round++) {
+    todo = size;
+    ind_len = 0;
+    ind_done = 0;
+    s = src;
+
+    // Count/copy the usable portion of the source line.
+    while (todo > 0 && ascii_iswhite(*s)) {
+      if (*s == TAB) {
+        tab_pad = (int)curbuf->b_p_ts
+                  - (ind_done % (int)curbuf->b_p_ts);
+
+        // Stop if this tab will overshoot the target.
+        if (todo < tab_pad) {
+          break;
+        }
+        todo -= tab_pad;
+        ind_done += tab_pad;
+      } else {
+        todo--;
+        ind_done++;
+      }
+      ind_len++;
+
+      if (p != NULL) {
+        *p++ = *s;
+      }
+      s++;
+    }
+
+    // Fill to next tabstop with a tab, if possible.
+    tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
+
+    if ((todo >= tab_pad) && !curbuf->b_p_et) {
+      todo -= tab_pad;
+      ind_len++;
+
+      if (p != NULL) {
+        *p++ = TAB;
+      }
+    }
+
+    // Add tabs required for indent.
+    while (todo >= (int)curbuf->b_p_ts && !curbuf->b_p_et) {
+