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

1 files changed, 142 insertions, 133 deletions

diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index 5a5257efb2..e19806e464 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -4,16 +4,25 @@
 #include <assert.h>
 #include <inttypes.h>
 #include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
 
 #include "nvim/ascii.h"
 #include "nvim/charset.h"
-#include "nvim/edit.h"
+#include "nvim/eval/typval_defs.h"
 #include "nvim/eval/vars.h"
+#include "nvim/gettext.h"
+#include "nvim/globals.h"
 #include "nvim/keycodes.h"
+#include "nvim/log.h"
+#include "nvim/macros.h"
+#include "nvim/mbyte.h"
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/mouse.h"
 #include "nvim/strings.h"
+#include "nvim/types.h"
 #include "nvim/vim.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
@@ -46,8 +55,7 @@ static const struct modmasktable {
 
 #define MOD_KEYS_ENTRY_SIZE 5
 
-static char_u modifier_keys_table[] =
-{
+static uint8_t modifier_keys_table[] = {
   //  mod mask      with modifier               without modifier
   MOD_MASK_SHIFT, '&', '9',                   '@', '1',         // begin
   MOD_MASK_SHIFT, '&', '0',                   '@', '2',         // cancel
@@ -57,15 +65,15 @@ static char_u modifier_keys_table[] =
   MOD_MASK_SHIFT, '*', '4',                   'k', 'D',         // delete char
   MOD_MASK_SHIFT, '*', '5',                   'k', 'L',         // delete line
   MOD_MASK_SHIFT, '*', '7',                   '@', '7',         // end
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_END,    '@', '7',         // end
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_END,         '@', '7',         // end
   MOD_MASK_SHIFT, '*', '9',                   '@', '9',         // exit
   MOD_MASK_SHIFT, '*', '0',                   '@', '0',         // find
   MOD_MASK_SHIFT, '#', '1',                   '%', '1',         // help
   MOD_MASK_SHIFT, '#', '2',                   'k', 'h',         // home
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_HOME,   'k', 'h',         // home
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_HOME,        'k', 'h',         // home
   MOD_MASK_SHIFT, '#', '3',                   'k', 'I',         // insert
   MOD_MASK_SHIFT, '#', '4',                   'k', 'l',         // left arrow
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_LEFT,   'k', 'l',         // left arrow
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_LEFT,        'k', 'l',         // left arrow
   MOD_MASK_SHIFT, '%', 'a',                   '%', '3',         // message
   MOD_MASK_SHIFT, '%', 'b',                   '%', '4',         // move
   MOD_MASK_SHIFT, '%', 'c',                   '%', '5',         // next
@@ -75,63 +83,63 @@ static char_u modifier_keys_table[] =
   MOD_MASK_SHIFT, '%', 'g',                   '%', '0',         // redo
   MOD_MASK_SHIFT, '%', 'h',                   '&', '3',         // replace
   MOD_MASK_SHIFT, '%', 'i',                   'k', 'r',         // right arr.
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_RIGHT,  'k', 'r',         // right arr.
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_RIGHT,       'k', 'r',         // right arr.
   MOD_MASK_SHIFT, '%', 'j',                   '&', '5',         // resume
   MOD_MASK_SHIFT, '!', '1',                   '&', '6',         // save
   MOD_MASK_SHIFT, '!', '2',                   '&', '7',         // suspend
   MOD_MASK_SHIFT, '!', '3',                   '&', '8',         // undo
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP,     'k', 'u',         // up arrow
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN,   'k', 'd',         // down arrow
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_UP,          'k', 'u',         // up arrow
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_DOWN,        'k', 'd',         // down arrow
 
   // vt100 F1
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1,    KS_EXTRA, (int)KE_XF1,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2,    KS_EXTRA, (int)KE_XF2,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3,    KS_EXTRA, (int)KE_XF3,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4,    KS_EXTRA, (int)KE_XF4,
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1,     'k', '1',         // F1
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2,     'k', '2',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3,     'k', '3',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4,     'k', '4',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5,     'k', '5',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6,     'k', '6',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7,     'k', '7',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8,     'k', '8',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9,     'k', '9',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10,    'k', ';',         // F10
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11,    'F', '1',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12,    'F', '2',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13,    'F', '3',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14,    'F', '4',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15,    'F', '5',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16,    'F', '6',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17,    'F', '7',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18,    'F', '8',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19,    'F', '9',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20,    'F', 'A',
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21,    'F', 'B',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22,    'F', 'C',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23,    'F', 'D',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24,    'F', 'E',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25,    'F', 'F',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26,    'F', 'G',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27,    'F', 'H',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28,    'F', 'I',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29,    'F', 'J',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30,    'F', 'K',
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31,    'F', 'L',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32,    'F', 'M',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33,    'F', 'N',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34,    'F', 'O',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35,    'F', 'P',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36,    'F', 'Q',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37,    'F', 'R',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF1,         KS_EXTRA, KE_XF1,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF2,         KS_EXTRA, KE_XF2,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF3,         KS_EXTRA, KE_XF3,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF4,         KS_EXTRA, KE_XF4,
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F1,          'k', '1',         // F1
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F2,          'k', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F3,          'k', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F4,          'k', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F5,          'k', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F6,          'k', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F7,          'k', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F8,          'k', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F9,          'k', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F10,         'k', ';',         // F10
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F11,         'F', '1',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F12,         'F', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F13,         'F', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F14,         'F', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F15,         'F', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F16,         'F', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F17,         'F', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F18,         'F', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F19,         'F', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F20,         'F', 'A',
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F21,         'F', 'B',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F22,         'F', 'C',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F23,         'F', 'D',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F24,         'F', 'E',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F25,         'F', 'F',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F26,         'F', 'G',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F27,         'F', 'H',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F28,         'F', 'I',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F29,         'F', 'J',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F30,         'F', 'K',
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F31,         'F', 'L',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F32,         'F', 'M',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F33,         'F', 'N',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F34,         'F', 'O',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F35,         'F', 'P',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F36,         'F', 'Q',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F37,         'F', 'R',
 
   // TAB pseudo code
-  MOD_MASK_SHIFT, 'k', 'B',                   KS_EXTRA, (int)KE_TAB,
+  MOD_MASK_SHIFT, 'k', 'B',                   KS_EXTRA, KE_TAB,
 
   NUL
 };
@@ -347,28 +355,27 @@ static struct mousetable {
   int button;                 // Which mouse button is it?
   bool is_click;              // Is it a mouse button click event?
   bool is_drag;               // Is it a mouse drag event?
-} mouse_table[] =
-{
-  { (int)KE_LEFTMOUSE,        MOUSE_LEFT,     true,   false },
-  { (int)KE_LEFTDRAG,         MOUSE_LEFT,     false,  true },
-  { (int)KE_LEFTRELEASE,      MOUSE_LEFT,     false,  false },
-  { (int)KE_MIDDLEMOUSE,      MOUSE_MIDDLE,   true,   false },
-  { (int)KE_MIDDLEDRAG,       MOUSE_MIDDLE,   false,  true },
-  { (int)KE_MIDDLERELEASE,    MOUSE_MIDDLE,   false,  false },
-  { (int)KE_RIGHTMOUSE,       MOUSE_RIGHT,    true,   false },
-  { (int)KE_RIGHTDRAG,        MOUSE_RIGHT,    false,  true },
-  { (int)KE_RIGHTRELEASE,     MOUSE_RIGHT,    false,  false },
-  { (int)KE_X1MOUSE,          MOUSE_X1,       true,   false },
-  { (int)KE_X1DRAG,           MOUSE_X1,       false,  true },
-  { (int)KE_X1RELEASE,        MOUSE_X1,       false,  false },
-  { (int)KE_X2MOUSE,          MOUSE_X2,       true,   false },
-  { (int)KE_X2DRAG,           MOUSE_X2,       false,  true },
-  { (int)KE_X2RELEASE,        MOUSE_X2,       false,  false },
+} mouse_table[] = {
+  { KE_LEFTMOUSE,        MOUSE_LEFT,     true,   false },
+  { KE_LEFTDRAG,         MOUSE_LEFT,     false,  true },
+  { KE_LEFTRELEASE,      MOUSE_LEFT,     false,  false },
+  { KE_MIDDLEMOUSE,      MOUSE_MIDDLE,   true,   false },
+  { KE_MIDDLEDRAG,       MOUSE_MIDDLE,   false,  true },
+  { KE_MIDDLERELEASE,    MOUSE_MIDDLE,   false,  false },
+  { KE_RIGHTMOUSE,       MOUSE_RIGHT,    true,   false },
+  { KE_RIGHTDRAG,        MOUSE_RIGHT,    false,  true },
+  { KE_RIGHTRELEASE,     MOUSE_RIGHT,    false,  false },
+  { KE_X1MOUSE,          MOUSE_X1,       true,   false },
+  { KE_X1DRAG,           MOUSE_X1,       false,  true },
+  { KE_X1RELEASE,        MOUSE_X1,       false,  false },
+  { KE_X2MOUSE,          MOUSE_X2,       true,   false },
+  { KE_X2DRAG,           MOUSE_X2,       false,  true },
+  { KE_X2RELEASE,        MOUSE_X2,       false,  false },
   // DRAG without CLICK
-  { (int)KE_MOUSEMOVE,        MOUSE_RELEASE,  false,  true },
+  { KE_MOUSEMOVE,        MOUSE_RELEASE,  false,  true },
   // RELEASE without CLICK
-  { (int)KE_IGNORE,           MOUSE_RELEASE,  false,  false },
-  { 0,                        0,              0,      0 },
+  { KE_IGNORE,           MOUSE_RELEASE,  false,  false },
+  { 0,                   0,              0,      0 },
 };
 
 /// Return the modifier mask bit (#MOD_MASK_*) corresponding to mod name
@@ -396,22 +403,24 @@ int name_to_mod_mask(int c)
 int simplify_key(const int key, int *modifiers)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) {
-    // TAB is a special case.
-    if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) {
-      *modifiers &= ~MOD_MASK_SHIFT;
-      return K_S_TAB;
-    }
-    const int key0 = KEY2TERMCAP0(key);
-    const int key1 = KEY2TERMCAP1(key);
-    for (int i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) {
-      if (key0 == modifier_keys_table[i + 3]
-          && key1 == modifier_keys_table[i + 4]
-          && (*modifiers & modifier_keys_table[i])) {
-        *modifiers &= ~modifier_keys_table[i];
-        return TERMCAP2KEY(modifier_keys_table[i + 1],
-                           modifier_keys_table[i + 2]);
-      }
+  if (!(*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT))) {
+    return key;
+  }
+
+  // TAB is a special case.
+  if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) {
+    *modifiers &= ~MOD_MASK_SHIFT;
+    return K_S_TAB;
+  }
+  const int key0 = KEY2TERMCAP0(key);
+  const int key1 = KEY2TERMCAP1(key);
+  for (int i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) {
+    if (key0 == modifier_keys_table[i + 3]
+        && key1 == modifier_keys_table[i + 4]
+        && (*modifiers & modifier_keys_table[i])) {
+      *modifiers &= ~modifier_keys_table[i];
+      return TERMCAP2KEY(modifier_keys_table[i + 1],
+                         modifier_keys_table[i + 2]);
     }
   }
   return key;
@@ -465,7 +474,7 @@ char_u *get_special_key_name(int c, int modifiers)
 
   int i, idx;
   int table_idx;
-  char_u *s;
+  char *s;
 
   string[0] = '<';
   idx = 1;
@@ -534,12 +543,12 @@ char_u *get_special_key_name(int c, int modifiers)
       } else {
         s = transchar(c);
         while (*s) {
-          string[idx++] = *s++;
+          string[idx++] = (uint8_t)(*s++);
         }
       }
     }
   } else {            // use name of special key
-    size_t len = STRLEN(key_names_table[table_idx].name);
+    size_t len = strlen(key_names_table[table_idx].name);
 
     if ((int)len + idx + 2 <= MAX_KEY_NAME_LEN) {
       STRCPY(string + idx, key_names_table[table_idx].name);
@@ -563,7 +572,7 @@ char_u *get_special_key_name(int c, int modifiers)
 /// @param[out]  did_simplify  found <C-H>, etc.
 ///
 /// @return Number of characters added to dst, zero for no match.
-unsigned int trans_special(const char_u **const srcp, const size_t src_len, char_u *const dst,
+unsigned int trans_special(const char **const srcp, const size_t src_len, char *const dst,
                            const int flags, const bool escape_ks, bool *const did_simplify)
   FUNC_ATTR_NONNULL_ARG(1, 3) FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -573,7 +582,7 @@ unsigned int trans_special(const char_u **const srcp, const size_t src_len, char
     return 0;
   }
 
-  return special_to_buf(key, modifiers, escape_ks, dst);
+  return special_to_buf(key, modifiers, escape_ks, (char_u *)dst);
 }
 
 /// Put the character sequence for "key" with "modifiers" into "dst" and return
@@ -616,15 +625,15 @@ unsigned int special_to_buf(int key, int modifiers, bool escape_ks, char_u *dst)
 /// @param[out]  did_simplify  FSK_SIMPLIFY and found <C-H>, etc.
 ///
 /// @return Key and modifiers or 0 if there is no match.
-int find_special_key(const char_u **const srcp, const size_t src_len, int *const modp,
+int find_special_key(const char **const srcp, const size_t src_len, int *const modp,
                      const int flags, bool *const did_simplify)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(1, 3)
 {
-  const char_u *last_dash;
-  const char_u *end_of_name;
-  const char_u *src;
-  const char_u *bp;
-  const char_u *const end = *srcp + src_len - 1;
+  const char *last_dash;
+  const char *end_of_name;
+  const char *src;
+  const char *bp;
+  const char *const end = *srcp + src_len - 1;
   const bool in_string = flags & FSK_IN_STRING;
   int modifiers;
   int bit;
@@ -682,7 +691,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
     modifiers = 0x0;
     for (bp = src + 1; bp < last_dash; bp++) {
       if (*bp != '-') {
-        bit = name_to_mod_mask(*bp);
+        bit = name_to_mod_mask((uint8_t)(*bp));
         if (bit == 0x0) {
           break;                // Illegal modifier name
         }
@@ -709,12 +718,12 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
           // Special case for a double-quoted string
           off = l = 2;
         } else {
-          l = utfc_ptr2len((char *)last_dash + 1);
+          l = utfc_ptr2len(last_dash + 1);
         }
         if (modifiers != 0 && last_dash[l + 1] == '>') {
-          key = utf_ptr2char((char *)last_dash + off);
+          key = utf_ptr2char(last_dash + off);
         } else {
-          key = get_special_key_code(last_dash + off);
+          key = get_special_key_code((char_u *)last_dash + off);
           if (!(flags & FSK_KEEP_X_KEY)) {
             key = handle_x_keys(key);
           }
@@ -861,10 +870,9 @@ int get_mouse_button(int code, bool *is_click, bool *is_drag)
 /// @param[in]  from  What characters to replace.
 /// @param[in]  from_len  Length of the "from" argument.
 /// @param[out]  bufp  Location where results were saved in case of success (allocated).
-///                    if *bufp is non-NULL, it will be used directly. it is
-///                    assumed to be 128 bytes long (enough for transcoding LHS
-///                    of mapping)
-///                    Will be set to NULL in case of failure.
+///                    If `*bufp` is non-NULL, it will be used directly,
+///                    and is assumed to be 128 bytes long (enough for transcoding LHS of mapping),
+///                    and will be set to NULL in case of failure.
 /// @param[in]  flags  REPTERM_FROM_PART    see above
 ///                    REPTERM_DO_LT        also translate <lt>
 ///                    REPTERM_NO_SPECIAL   do not accept <key> notation
@@ -872,18 +880,18 @@ int get_mouse_button(int code, bool *is_click, bool *is_drag)
 /// @param[out]  did_simplify  set when some <C-H> code was simplied, unless it is NULL.
 /// @param[in]  cpo_flags  Relevant flags derived from p_cpo, see CPO_TO_CPO_FLAGS.
 ///
-/// @return  Pointer to an allocated memory, which is also saved to "bufp".
+/// @return  The same as what `*bufp` is set to.
 char *replace_termcodes(const char *const from, const size_t from_len, char **const bufp,
                         const int flags, bool *const did_simplify, const int cpo_flags)
   FUNC_ATTR_NONNULL_ARG(1, 3)
 {
   ssize_t i;
   size_t slen;
-  char_u key;
+  char key;
   size_t dlen = 0;
-  const char_u *src;
-  const char_u *const end = (char_u *)from + from_len - 1;
-  char_u *result;          // buffer for resulting string
+  const char *src;
+  const char *const end = from + from_len - 1;
+  char *result;          // buffer for resulting string
 
   const bool do_backslash = !(cpo_flags & FLAG_CPO_BSLASH);  // backslash is a special character
   const bool do_special = !(flags & REPTERM_NO_SPECIAL);
@@ -895,12 +903,12 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
   const size_t buf_len = allocated ? from_len * 6 + 1 : 128;
   result = allocated ? xmalloc(buf_len) : *bufp;
 
-  src = (char_u *)from;
+  src = from;
 
   // Check for #n at start only: function key n
   if ((flags & REPTERM_FROM_PART) && from_len > 1 && src[0] == '#'
       && ascii_isdigit(src[1])) {  // function key
-    result[dlen++] = K_SPECIAL;
+    result[dlen++] = (char)K_SPECIAL;
     result[dlen++] = 'k';
     if (src[1] == '0') {
       result[dlen++] = ';';     // #0 is F10 is "k;"
@@ -917,7 +925,7 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
     }
     // Check for special <> keycodes, like "<C-S-LeftMouse>"
     if (do_special && ((flags & REPTERM_DO_LT) || ((end - src) >= 3
-                                                   && STRNCMP(src, "<lt>", 4) != 0))) {
+                                                   && strncmp(src, "<lt>", 4) != 0))) {
       // Replace <SID> by K_SNR <script-nr> _.
       // (room: 5 * 6 = 30 bytes; needed: 3 + <nr> + 1 <= 14)
       if (end - src >= 4 && STRNICMP(src, "<SID>", 5) == 0) {
@@ -925,12 +933,12 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
           emsg(_(e_usingsid));
         } else {
           src += 5;
-          result[dlen++] = K_SPECIAL;
-          result[dlen++] = (int)KS_EXTRA;
-          result[dlen++] = (int)KE_SNR;
-          snprintf((char *)result + dlen, buf_len - dlen, "%" PRId64,
+          result[dlen++] = (char)K_SPECIAL;
+          result[dlen++] = (char)KS_EXTRA;
+          result[dlen++] = KE_SNR;
+          snprintf(result + dlen, buf_len - dlen, "%" PRId64,
                    (int64_t)current_sctx.sc_sid);
-          dlen += STRLEN(result + dlen);
+          dlen += strlen(result + dlen);
           result[dlen++] = '_';
           continue;
         }
@@ -946,7 +954,8 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
     }
 
     if (do_special) {
-      char_u *p, *s, len;
+      char *p, *s;
+      int len;
 
       // Replace <Leader> by the value of "mapleader".
       // Replace <LocalLeader> by the value of "maplocalleader".
@@ -964,8 +973,8 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
 
       if (len != 0) {
         // Allow up to 8 * 6 characters for "mapleader".
-        if (p == NULL || *p == NUL || STRLEN(p) > 8 * 6) {
-          s = (char_u *)"\\";
+        if (p == NULL || *p == NUL || strlen(p) > 8 * 6) {
+          s = "\\";
         } else {
           s = p;
         }
@@ -993,12 +1002,12 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
     }
 
     // skip multibyte char correctly
-    for (i = utfc_ptr2len_len(src, (int)(end - src) + 1); i > 0; i--) {
+    for (i = utfc_ptr2len_len((char *)src, (int)(end - src) + 1); i > 0; i--) {
       // If the character is K_SPECIAL, replace it with K_SPECIAL
       // KS_SPECIAL KE_FILLER.
-      if (*src == K_SPECIAL) {
-        result[dlen++] = K_SPECIAL;
-        result[dlen++] = KS_SPECIAL;
+      if (*src == (char)K_SPECIAL) {
+        result[dlen++] = (char)K_SPECIAL;
+        result[dlen++] = (char)KS_SPECIAL;
         result[dlen++] = KE_FILLER;
       } else {
         result[dlen++] = *src;
@@ -1050,8 +1059,8 @@ char *vim_strsave_escape_ks(char *p)
   // Need a buffer to hold up to three times as much.  Four in case of an
   // illegal utf-8 byte:
   // 0xc0 -> 0xc3 - 0x80 -> 0xc3 K_SPECIAL KS_SPECIAL KE_FILLER
-  char_u *res = xmalloc(STRLEN(p) * 4 + 1);
-  char_u *d = res;
+  char *res = xmalloc(strlen(p) * 4 + 1);
+  char_u *d = (char_u *)res;
   for (char_u *s = (char_u *)p; *s != NUL;) {
     if (s[0] == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
       // Copy special key unmodified.
@@ -1067,7 +1076,7 @@ char *vim_strsave_escape_ks(char *p)
   }
   *d = NUL;
 
-  return (char *)res;
+  return res;
 }
 
 /// Remove escaping from K_SPECIAL characters.  Reverse of