Merge #8665 'Remove mb_ptr2char macro'

src/nvim/buffer.c

@@ -3220,10 +3220,11 @@ int build_stl_str_hl(
   // Get the byte value now, in case we need it below. This is more
   // efficient than making a copy of the line.
   int byteval;
-  if (wp->w_cursor.col > (colnr_T)STRLEN(line_ptr))
+  if (wp->w_cursor.col > (colnr_T)STRLEN(line_ptr)) {
     byteval = 0;
-  else
+  } else {
-    byteval = (*mb_ptr2char)(line_ptr + wp->w_cursor.col);
+    byteval = utf_ptr2char(line_ptr + wp->w_cursor.col);
+  }
 
   int groupdepth = 0;
 

src/nvim/charset.c

@@ -1379,7 +1379,7 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor,
     ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);
 
     if (pos->col < (colnr_T)STRLEN(ptr)) {
-      int c = (*mb_ptr2char)(ptr + pos->col);
+      int c = utf_ptr2char(ptr + pos->col);
       if ((c != TAB) && vim_isprintc(c)) {
         endadd = (colnr_T)(char2cells(c) - 1);
         if (coladd > endadd) {

src/nvim/cursor.c

@@ -476,9 +476,7 @@ bool leftcol_changed(void)
 
 int gchar_cursor(void)
 {
-  if (has_mbyte)
+  return utf_ptr2char(get_cursor_pos_ptr());
-    return (*mb_ptr2char)(get_cursor_pos_ptr());
-  return (int)*get_cursor_pos_ptr();
 }
 
 /*
@@ -507,4 +505,3 @@ char_u *get_cursor_pos_ptr(void)
   return ml_get_buf(curbuf, curwin->w_cursor.lnum, false) +
          curwin->w_cursor.col;
 }
-

src/nvim/digraph.c

@@ -1536,7 +1536,7 @@ static int getexactdigraph(int char1, int char2, int meta_char)
       to = string_convert(&vc, buf, &len);
 
       if (to != NULL) {
-        retval = (*mb_ptr2char)(to);
+        retval = utf_ptr2char(to);
         xfree(to);
       }
       (void)convert_setup(&vc, NULL, NULL);

src/nvim/edit.c

@@ -2311,24 +2311,14 @@ static void ins_compl_longest_match(compl_T *match)
     p = compl_leader;
     s = match->cp_str;
     while (*p != NUL) {
-      if (has_mbyte) {
+      c1 = utf_ptr2char(p);
-        c1 = mb_ptr2char(p);
+      c2 = utf_ptr2char(s);
-        c2 = mb_ptr2char(s);
+
-      } else {
+      if (match->cp_icase ? (mb_tolower(c1) != mb_tolower(c2)) : (c1 != c2)) {
-        c1 = *p;
-        c2 = *s;
-      }
-      if (match->cp_icase ? (mb_tolower(c1) != mb_tolower(c2))
-          : (c1 != c2)) {
         break;
       }
-      if (has_mbyte) {
+      MB_PTR_ADV(p);
-        MB_PTR_ADV(p);
+      MB_PTR_ADV(s);
-        MB_PTR_ADV(s);
-      } else {
-        ++p;
-        ++s;
-      }
     }
 
     if (*p != NUL) {
@@ -6198,12 +6188,10 @@ int oneright(void)
 
     /* Adjust for multi-wide char (excluding TAB) */
     ptr = get_cursor_pos_ptr();
-    coladvance(getviscol() + ((*ptr != TAB && vim_isprintc(
+    coladvance(getviscol() + ((*ptr != TAB && vim_isprintc(utf_ptr2char(ptr))) ?
-                                   (*mb_ptr2char)(ptr)
+                              ptr2cells(ptr) : 1));
-                                   ))
+    curwin->w_set_curswant = true;
-                              ? ptr2cells(ptr) : 1));
+    // Return OK if the cursor moved, FAIL otherwise (at window edge).
-    curwin->w_set_curswant = TRUE;
-    /* Return OK if the cursor moved, FAIL otherwise (at window edge). */
     return (prevpos.col != curwin->w_cursor.col
             || prevpos.coladd != curwin->w_cursor.coladd) ? OK : FAIL;
   }
@@ -6258,10 +6246,10 @@ int oneleft(void)
 
       /* Adjust for multi-wide char (not a TAB) */
       ptr = get_cursor_pos_ptr();
-      if (*ptr != TAB && vim_isprintc(
+      if (*ptr != TAB && vim_isprintc(utf_ptr2char(ptr))
-              (*mb_ptr2char)(ptr)
+          && ptr2cells(ptr) > 1) {
-              ) && ptr2cells(ptr) > 1)
         curwin->w_cursor.coladd = 0;
+      }
     }
 
     curwin->w_set_curswant = TRUE;
@@ -8496,7 +8484,7 @@ int ins_copychar(linenr_T lnum)
   if ((colnr_T)temp > curwin->w_virtcol)
     ptr = prev_ptr;
 
-  c = (*mb_ptr2char)(ptr);
+  c = utf_ptr2char(ptr);
   if (c == NUL) {
     vim_beep(BO_COPY);
   }

src/nvim/eval.c

@@ -15896,7 +15896,7 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   while (charidx >= 0 && byteidx < len) {
     if (charidx == 0) {
-      rettv->vval.v_number = mb_ptr2char((const char_u *)str + byteidx);
+      rettv->vval.v_number = utf_ptr2char((const char_u *)str + byteidx);
       break;
     }
     charidx--;

src/nvim/ex_cmds.c

@@ -5641,7 +5641,7 @@ void ex_sign(exarg_T *eap)
             // Count cells and check for non-printable chars
             cells = 0;
             for (s = arg; s < p; s += (*mb_ptr2len)(s)) {
-              if (!vim_isprintc((*mb_ptr2char)(s))) {
+              if (!vim_isprintc(utf_ptr2char(s))) {
                 break;
               }
               cells += (*mb_ptr2cells)(s);

src/nvim/ex_docmd.c

@@ -2899,11 +2899,7 @@ const char * set_one_cmd_context(
     xp->xp_pattern = skipwhite((const char_u *)arg);
     p = (const char *)xp->xp_pattern;
     while (*p != NUL) {
-      if (has_mbyte) {
+      c = utf_ptr2char((const char_u *)p);
-        c = mb_ptr2char((const char_u *)p);
-      } else {
-        c = (uint8_t)(*p);
-      }
       if (c == '\\' && p[1] != NUL) {
         p++;
       } else if (c == '`') {
@@ -2921,19 +2917,11 @@ const char * set_one_cmd_context(
             || ascii_iswhite(c)) {
         len = 0;          /* avoid getting stuck when space is in 'isfname' */
         while (*p != NUL) {
-          if (has_mbyte) {
+          c = utf_ptr2char((const char_u *)p);
-            c = mb_ptr2char((const char_u *)p);
-          } else {
-            c = *p;
-          }
           if (c == '`' || vim_isfilec_or_wc(c)) {
             break;
           }
-          if (has_mbyte) {
+          len = (size_t)utfc_ptr2len((const char_u *)p);
-            len = (size_t)(*mb_ptr2len)((const char_u *)p);
-          } else {
-            len = 1;
-          }
           MB_PTR_ADV(p);
         }
         if (in_quote) {

src/nvim/ex_getln.c

@@ -3327,16 +3327,11 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
 
       /* Locate start of last word in the cmd buffer. */
       for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff; ) {
-        if (has_mbyte) {
+        len = utf_head_off(ccline.cmdbuff, w - 1) + 1;
-          len = (*mb_head_off)(ccline.cmdbuff, w - 1) + 1;
+        if (!vim_iswordc(utf_ptr2char(w - len))) {
-          if (!vim_iswordc(mb_ptr2char(w - len)))
+          break;
-            break;
-          w -= len;
-        } else {
-          if (!vim_iswordc(w[-1]))
-            break;
-          --w;
         }
+        w -= len;
       }
       len = (int)((ccline.cmdbuff + ccline.cmdpos) - w);
       if (p_ic ? STRNICMP(w, arg, len) == 0 : STRNCMP(w, arg, len) == 0)
@@ -3837,24 +3832,13 @@ ExpandOne (
 
   // Find longest common part
   if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
-    size_t len;
+    size_t len = 0;
-    size_t mb_len = 1;
-    int c0;
-    int ci;
 
-    for (len = 0; xp->xp_files[0][len]; len += mb_len) {
+    for (size_t mb_len; xp->xp_files[0][len]; len += mb_len) {
-      if (has_mbyte) {
+      mb_len = utfc_ptr2len(&xp->xp_files[0][len]);
-        mb_len = (* mb_ptr2len)(&xp->xp_files[0][len]);
+      int c0 = utf_ptr2char(&xp->xp_files[0][len]);
-        c0 = (* mb_ptr2char)(&xp->xp_files[0][len]);
+      for (i = 1; i < xp->xp_numfiles; i++) {
-      } else {
+        int ci = utf_ptr2char(&xp->xp_files[i][len]);
-        c0 = xp->xp_files[0][len];
-      }
-      for (i = 1; i < xp->xp_numfiles; ++i) {
-        if (has_mbyte) {
-          ci =(* mb_ptr2char)(&xp->xp_files[i][len]);
-        } else {
-          ci = xp->xp_files[i][len];
-        }
 
         if (p_fic && (xp->xp_context == EXPAND_DIRECTORIES
                       || xp->xp_context == EXPAND_FILES

src/nvim/fold.c

@@ -1763,12 +1763,13 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume,
     if (text != NULL) {
       /* Replace unprintable characters, if there are any.  But
        * replace a TAB with a space. */
-      for (p = text; *p != NUL; ++p) {
+      for (p = text; *p != NUL; p++) {
-        int len;
+        int len = utfc_ptr2len(p);
 
-        if (has_mbyte && (len = (*mb_ptr2len)(p)) > 1) {
+        if (len > 1) {
-          if (!vim_isprintc((*mb_ptr2char)(p)))
+          if (!vim_isprintc(utf_ptr2char(p))) {
             break;
+          }
           p += len - 1;
         } else if (*p == TAB)
           *p = ' ';

src/nvim/getchar.c

@@ -701,7 +701,7 @@ static int read_redo(int init, int old_redo)
     buf[i] = (char_u)c;
     if (i == n - 1) {         // last byte of a character
       if (n != 1) {
-        c = (*mb_ptr2char)(buf);
+        c = utf_ptr2char(buf);
       }
       break;
     }
@@ -1486,7 +1486,7 @@ int vgetc(void)
           }
         }
         no_mapping--;
-        c = (*mb_ptr2char)(buf);
+        c = utf_ptr2char(buf);
       }
 
       break;

src/nvim/macros.h

@@ -126,7 +126,7 @@
 
 # define MB_CHARLEN(p)      mb_charlen(p)
 # define MB_CHAR2LEN(c)     mb_char2len(c)
-# define PTR2CHAR(p)        mb_ptr2char(p)
+# define PTR2CHAR(p)        utf_ptr2char(p)
 
 # define RESET_BINDING(wp)  (wp)->w_p_scb = FALSE; (wp)->w_p_crb = FALSE
 

src/nvim/mark.c

@@ -1470,7 +1470,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
     // double-wide character.
     if (lp->coladd == 1
         && p[lp->col] != TAB
-        && vim_isprintc((*mb_ptr2char)(p + lp->col))
+        && vim_isprintc(utf_ptr2char(p + lp->col))
         && ptr2cells(p + lp->col) > 1) {
       lp->coladd = 0;
     }

src/nvim/mbyte.c

@@ -674,7 +674,7 @@ int mb_ptr2char_adv(const char_u **const pp)
 {
   int c;
 
-  c = (*mb_ptr2char)(*pp);
+  c = utf_ptr2char(*pp);
   *pp += (*mb_ptr2len)(*pp);
   return c;
 }
@@ -687,7 +687,7 @@ int mb_cptr2char_adv(const char_u **pp)
 {
   int c;
 
-  c = (*mb_ptr2char)(*pp);
+  c = utf_ptr2char(*pp);
   *pp += utf_ptr2len(*pp);
   return c;
 }
@@ -1714,7 +1714,7 @@ void mb_check_adjust_col(void *win_)
     // Reset `coladd` when the cursor would be on the right half of a
     // double-wide character.
     if (win->w_cursor.coladd == 1 && p[win->w_cursor.col] != TAB
-        && vim_isprintc((*mb_ptr2char)(p + win->w_cursor.col))
+        && vim_isprintc(utf_ptr2char(p + win->w_cursor.col))
         && ptr2cells(p + win->w_cursor.col) > 1) {
       win->w_cursor.coladd = 0;
     }

src/nvim/mbyte.h

@@ -54,7 +54,6 @@ enum { MAX_MCO = 6 };
 #define mb_ptr2cells_len utf_ptr2cells_len
 #define mb_char2cells utf_char2cells
 #define mb_off2cells utf_off2cells
-#define mb_ptr2char utf_ptr2char
 #define mb_head_off utf_head_off
 
 /// Flags for vimconv_T

src/nvim/message.c

@@ -1219,7 +1219,7 @@ int msg_outtrans_len_attr(char_u *msgstr, int len, int attr)
     // Don't include composing chars after the end.
     mb_l = utfc_ptr2len_len((char_u *)str, len + 1);
     if (mb_l > 1) {
-      c = (*mb_ptr2char)((char_u *)str);
+      c = utf_ptr2char((char_u *)str);
       if (vim_isprintc(c)) {
         // Printable multi-byte char: count the cells.
         retval += (*mb_ptr2cells)((char_u *)str);
@@ -1480,7 +1480,7 @@ void msg_prt_line(char_u *s, int list)
       col += (*mb_ptr2cells)(s);
       char buf[MB_MAXBYTES + 1];
       if (lcs_nbsp != NUL && list
-          && (mb_ptr2char(s) == 160 || mb_ptr2char(s) == 0x202f)) {
+          && (utf_ptr2char(s) == 160 || utf_ptr2char(s) == 0x202f)) {
         mb_char2bytes(lcs_nbsp, (char_u *)buf);
         buf[(*mb_ptr2len)((char_u *)buf)] = NUL;
       } else {
@@ -2866,14 +2866,12 @@ do_dialog (
       // Make the character lowercase, as chars in "hotkeys" are.
       c = mb_tolower(c);
       retval = 1;
-      for (i = 0; hotkeys[i]; ++i) {
+      for (i = 0; hotkeys[i]; i++) {
-        if (has_mbyte) {
+        if (utf_ptr2char(hotkeys + i) == c) {
-          if ((*mb_ptr2char)(hotkeys + i) == c)
-            break;
-          i += (*mb_ptr2len)(hotkeys + i) - 1;
-        } else if (hotkeys[i] == c)
           break;
-        ++retval;
+        }
+        i += utfc_ptr2len(hotkeys + i) - 1;
+        retval++;
       }
       if (hotkeys[i])
         break;
@@ -2905,25 +2903,13 @@ copy_char (
     int lowercase                  /* make character lower case */
 )
 {
-  int len;
+  if (lowercase) {
-  int c;
+    int c = mb_tolower(utf_ptr2char(from));
-
+    return utf_char2bytes(c, to);
-  if (has_mbyte) {
-    if (lowercase) {
-      c = mb_tolower((*mb_ptr2char)(from));
-      return (*mb_char2bytes)(c, to);
-    } else {
-      len = (*mb_ptr2len)(from);
-      memmove(to, from, (size_t)len);
-      return len;
-    }
-  } else {
-    if (lowercase)
-      *to = (char_u)TOLOWER_LOC(*from);
-    else
-      *to = *from;
-    return 1;
   }
+  int len = utfc_ptr2len(from);
+  memmove(to, from, (size_t)len);
+  return len;
 }
 
 #define HAS_HOTKEY_LEN 30

src/nvim/misc1.c

@@ -701,13 +701,12 @@ open_line (
       replace_push(NUL);            /* end of extra blanks */
     if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES)) {
       while ((*p_extra == ' ' || *p_extra == '\t')
-             && (!enc_utf8
+             && !utf_iscomposing(utf_ptr2char(p_extra + 1))) {
-                 || !utf_iscomposing(utf_ptr2char(p_extra + 1)))
+        if (REPLACE_NORMAL(State)) {
-             ) {
-        if (REPLACE_NORMAL(State))
           replace_push(*p_extra);
-        ++p_extra;
+        }
-        ++less_cols_off;
+        p_extra++;
+        less_cols_off++;
       }
     }
     if (*p_extra != NUL) {
@@ -1512,7 +1511,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
       && msg_silent == 0
       && !ins_compl_active()
       ) {
-    showmatch(mb_ptr2char(buf));
+    showmatch(utf_ptr2char(buf));
   }
 
   if (!p_ri || (State & REPLACE_FLAG)) {
@@ -1749,11 +1748,7 @@ del_lines (
 
 int gchar_pos(pos_T *pos)
 {
-  char_u      *ptr = ml_get_pos(pos);
+  return utf_ptr2char(ml_get_pos(pos));
-
-  if (has_mbyte)
-    return (*mb_ptr2char)(ptr);
-  return (int)*ptr;
 }
 
 /*
@@ -2389,12 +2384,12 @@ int get_keystroke(void)
       }
       break;
     }
-    if (has_mbyte) {
+    if (MB_BYTE2LEN(n) > len) {
-      if (MB_BYTE2LEN(n) > len)
+      // more bytes to get.
-        continue;               /* more bytes to get */
+      continue;
-      buf[len >= buflen ? buflen - 1 : len] = NUL;
-      n = (*mb_ptr2char)(buf);
     }
+    buf[len >= buflen ? buflen - 1 : len] = NUL;
+    n = utf_ptr2char(buf);
 #ifdef UNIX
     if (n == intr_char)
       n = ESC;
@@ -2840,4 +2835,3 @@ int goto_im(void)
 {
   return p_im && stuff_empty() && typebuf_typed();
 }
-

src/nvim/ops.c

@@ -3620,9 +3620,9 @@ int do_join(size_t count,
       curr = skipwhite(curr);
       if (*curr != ')' && currsize != 0 && endcurr1 != TAB
           && (!has_format_option(FO_MBYTE_JOIN)
-              || (mb_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
+              || (utf_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
           && (!has_format_option(FO_MBYTE_JOIN2)
-              || mb_ptr2char(curr) < 0x100 || endcurr1 < 0x100)
+              || utf_ptr2char(curr) < 0x100 || endcurr1 < 0x100)
           ) {
         /* don't add a space if the line is ending in a space */
         if (endcurr1 == ' ')
@@ -3639,18 +3639,12 @@ int do_join(size_t count,
     sumsize += currsize + spaces[t];
     endcurr1 = endcurr2 = NUL;
     if (insert_space && currsize > 0) {
-      if (has_mbyte) {
+      cend = curr + currsize;
-        cend = curr + currsize;
+      MB_PTR_BACK(curr, cend);
+      endcurr1 = utf_ptr2char(cend);
+      if (cend > curr) {
         MB_PTR_BACK(curr, cend);
-        endcurr1 = (*mb_ptr2char)(cend);
+        endcurr2 = utf_ptr2char(cend);
-        if (cend > curr) {
-          MB_PTR_BACK(curr, cend);
-          endcurr2 = (*mb_ptr2char)(cend);
-        }
-      } else {
-        endcurr1 = *(curr + currsize - 1);
-        if (currsize > 1)
-          endcurr2 = *(curr + currsize - 2);
       }
     }
     line_breakcheck();

src/nvim/option.c

@@ -2703,7 +2703,7 @@ did_set_string_option (
         if (*p != NUL)
           x2 = *p++;
         if (*p != NUL) {
-          x3 = mb_ptr2char(p);
+          x3 = utf_ptr2char(p);
           p += mb_ptr2len(p);
         }
         if (x2 != ':' || x3 == -1 || (*p != NUL && *p != ',')) {
@@ -6406,22 +6406,25 @@ static void langmap_set(void)
         ++p;
         break;
       }
-      if (p[0] == '\\' && p[1] != NUL)
+      if (p[0] == '\\' && p[1] != NUL) {
-        ++p;
+        p++;
-      from = (*mb_ptr2char)(p);
+      }
+      from = utf_ptr2char(p);
       to = NUL;
       if (p2 == NULL) {
         MB_PTR_ADV(p);
         if (p[0] != ',') {
-          if (p[0] == '\\')
+          if (p[0] == '\\') {
-            ++p;
+            p++;
-          to = (*mb_ptr2char)(p);
+          }
+          to = utf_ptr2char(p);
         }
       } else {
         if (p2[0] != ',') {
-          if (p2[0] == '\\')
+          if (p2[0] == '\\') {
-            ++p2;
+            p2++;
-          to = (*mb_ptr2char)(p2);
+          }
+          to = utf_ptr2char(p2);
         }
       }
       if (to == NUL) {
@@ -6846,66 +6849,37 @@ int get_sts_value(void)
  */
 void find_mps_values(int *initc, int *findc, int *backwards, int switchit)
 {
-  char_u      *ptr;
+  char_u *ptr = curbuf->b_p_mps;
 
-  ptr = curbuf->b_p_mps;
   while (*ptr != NUL) {
-    if (has_mbyte) {
+    if (utf_ptr2char(ptr) == *initc) {
-      char_u *prev;
+      if (switchit) {
-
+        *findc = *initc;
-      if (mb_ptr2char(ptr) == *initc) {
+        *initc = utf_ptr2char(ptr + utfc_ptr2len(ptr) + 1);
-        if (switchit) {
+        *backwards = true;
-          *findc = *initc;
+      } else {
-          *initc = mb_ptr2char(ptr + mb_ptr2len(ptr) + 1);
+        *findc = utf_ptr2char(ptr + utfc_ptr2len(ptr) + 1);
-          *backwards = TRUE;
+        *backwards = false;
-        } else {
-          *findc = mb_ptr2char(ptr + mb_ptr2len(ptr) + 1);
-          *backwards = FALSE;
-        }
-        return;
       }
-      prev = ptr;
+      return;
-      ptr += mb_ptr2len(ptr) + 1;
+    }
-      if (mb_ptr2char(ptr) == *initc) {
+    char_u *prev = ptr;
-        if (switchit) {
+    ptr += utfc_ptr2len(ptr) + 1;
-          *findc = *initc;
+    if (utf_ptr2char(ptr) == *initc) {
-          *initc = mb_ptr2char(prev);
+      if (switchit) {
-          *backwards = FALSE;
+        *findc = *initc;
-        } else {
+        *initc = utf_ptr2char(prev);
-          *findc = mb_ptr2char(prev);
+        *backwards = false;
-          *backwards = TRUE;
+      } else {
-        }
+        *findc = utf_ptr2char(prev);
-        return;
+        *backwards = true;
-      }
+      }
-      ptr += mb_ptr2len(ptr);
+      return;
-    } else {
+    }
-      if (*ptr == *initc) {
+    ptr += utfc_ptr2len(ptr);
-        if (switchit) {
+    if (*ptr == ',') {
-          *backwards = TRUE;
+      ptr++;
-          *findc = *initc;
-          *initc = ptr[2];
-        } else {
-          *backwards = FALSE;
-          *findc = ptr[2];
-        }
-        return;
-      }
-      ptr += 2;
-      if (*ptr == *initc) {
-        if (switchit) {
-          *backwards = FALSE;
-          *findc = *initc;
-          *initc = ptr[-2];
-        } else {
-          *backwards = TRUE;
-          *findc =  ptr[-2];
-        }
-        return;
-      }
-      ++ptr;
     }
-    if (*ptr == ',')
-      ++ptr;
   }
 }
 

src/nvim/regexp.c

@@ -772,13 +772,9 @@ static int get_equi_class(char_u **pp)
   char_u      *p = *pp;
 
   if (p[1] == '=') {
-    if (has_mbyte)
+    l = (*mb_ptr2len)(p + 2);
-      l = (*mb_ptr2len)(p + 2);
     if (p[l + 2] == '=' && p[l + 3] == ']') {
-      if (has_mbyte)
+      c = utf_ptr2char(p + 2);
-        c = mb_ptr2char(p + 2);
-      else
-        c = p[2];
       *pp += l + 4;
       return c;
     }
@@ -1107,13 +1103,9 @@ static int get_coll_element(char_u **pp)
   char_u      *p = *pp;
 
   if (p[0] != NUL && p[1] == '.') {
-    if (has_mbyte)
+    l = utfc_ptr2len(p + 2);
-      l = (*mb_ptr2len)(p + 2);
     if (p[l + 2] == '.' && p[l + 3] == ']') {
-      if (has_mbyte)
+      c = utf_ptr2char(p + 2);
-        c = mb_ptr2char(p + 2);
-      else
-        c = p[2];
       *pp += l + 4;
       return c;
     }
@@ -1299,10 +1291,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
     }
 
     if (OP(scan) == EXACTLY) {
-      if (has_mbyte)
+      r->regstart = utf_ptr2char(OPERAND(scan));
-        r->regstart = (*mb_ptr2char)(OPERAND(scan));
-      else
-        r->regstart = *OPERAND(scan);
     } else if (OP(scan) == BOW
                || OP(scan) == EOW
                || OP(scan) == NOTHING
@@ -1310,10 +1299,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
                || OP(scan) == MCLOSE + 0 || OP(scan) == NCLOSE) {
       char_u *regnext_scan = regnext(scan);
       if (OP(regnext_scan) == EXACTLY) {
-        if (has_mbyte)
+        r->regstart = utf_ptr2char(OPERAND(regnext_scan));
-          r->regstart = (*mb_ptr2char)(OPERAND(regnext_scan));
-        else
-          r->regstart = *OPERAND(regnext_scan);
       }
     }
 
@@ -2412,20 +2398,16 @@ collection:
               break;
             }
           } else {
-            if (has_mbyte) {
+            // produce a multibyte character, including any
-              int len;
+            // following composing characters.
-
+            startc = utf_ptr2char(regparse);
-              /* produce a multibyte character, including any
+            int len = utfc_ptr2len(regparse);
-               * following composing characters */
+            if (utf_char2len(startc) != len) {
-              startc = mb_ptr2char(regparse);
+              // composing chars
-              len = (*mb_ptr2len)(regparse);
+              startc = -1;
-              if (enc_utf8 && utf_char2len(startc) != len)
+            }
-                startc = -1;                    /* composing chars */
+            while (--len >= 0) {
-              while (--len >= 0)
+              regc(*regparse++);
-                regc(*regparse++);
-            } else {
-              startc = *regparse++;
-              regc(startc);
             }
           }
         }
@@ -2906,17 +2888,13 @@ static int peekchr(void)
        * Next character can never be (made) magic?
        * Then backslashing it won't do anything.
        */
-      if (has_mbyte)
+      curchr = utf_ptr2char(regparse + 1);
-        curchr = (*mb_ptr2char)(regparse + 1);
-      else
-        curchr = c;
     }
     break;
   }
 
   default:
-    if (has_mbyte)
+    curchr = utf_ptr2char(regparse);
-      curchr = (*mb_ptr2char)(regparse);
   }
 
   return curchr;
@@ -3466,12 +3444,7 @@ static long bt_regexec_both(char_u *line,
 
   /* If there is a "must appear" string, look for it. */
   if (prog->regmust != NULL) {
-    int c;
+    int c = utf_ptr2char(prog->regmust);
-
-    if (has_mbyte)
-      c = (*mb_ptr2char)(prog->regmust);
-    else
-      c = *prog->regmust;
     s = line + col;
 
     // This is used very often, esp. for ":global".  Use two versions of
@@ -3502,16 +3475,11 @@ static long bt_regexec_both(char_u *line,
 
   /* Simplest case: Anchored match need be tried only once. */
   if (prog->reganch) {
-    int c;
+    int c = utf_ptr2char(regline + col);
-
-    if (has_mbyte)
-      c = (*mb_ptr2char)(regline + col);
-    else
-      c = regline[col];
     if (prog->regstart == NUL
         || prog->regstart == c
         || (rex.reg_ic
-            && (((enc_utf8 && utf_fold(prog->regstart) == utf_fold(c)))
+            && (utf_fold(prog->regstart) == utf_fold(c)
                 || (c < 255 && prog->regstart < 255
                     && mb_tolower(prog->regstart) == mb_tolower(c))))) {
       retval = regtry(prog, col);
@@ -3858,12 +3826,10 @@ regmatch (
       } else if (rex.reg_line_lbr && WITH_NL(op) && *reginput == '\n') {
         ADVANCE_REGINPUT();
       } else {
-        if (WITH_NL(op))
+        if (WITH_NL(op)) {
           op -= ADD_NL;
-        if (has_mbyte)
+        }
-          c = (*mb_ptr2char)(reginput);
+        c = utf_ptr2char(reginput);
-        else
-          c = *reginput;
         switch (op) {
         case BOL:
           if (reginput != regline)
@@ -5473,8 +5439,8 @@ do_class:
         }
       } else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) {
         scan++;
-      } else if (has_mbyte && (len = (*mb_ptr2len)(scan)) > 1) {
+      } else if ((len = utfc_ptr2len(scan)) > 1) {
-        if ((cstrchr(opnd, (*mb_ptr2char)(scan)) == NULL) == testval) {
+        if ((cstrchr(opnd, utf_ptr2char(scan)) == NULL) == testval) {
           break;
         }
         scan += len;
@@ -6782,18 +6748,18 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
           }
             c = *src++;
           }
-        } else if (has_mbyte)
+        } else {
-          c = mb_ptr2char(src - 1);
+          c = utf_ptr2char(src - 1);
-
+        }
-        /* Write to buffer, if copy is set. */
+        // Write to buffer, if copy is set.
-        if (func_one != (fptr_T)NULL)
+        if (func_one != NULL) {
-          /* Turbo C complains without the typecast */
           func_one = (fptr_T)(func_one(&cc, c));
-        else if (func_all != (fptr_T)NULL)
+        } else if (func_all != NULL) {
-          /* Turbo C complains without the typecast */
           func_all = (fptr_T)(func_all(&cc, c));
-        else     /* just copy */
+        } else {
+          // just copy
           cc = c;
+        }
 
         if (has_mbyte) {
           int totlen = mb_ptr2len(src - 1);
@@ -6878,10 +6844,7 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
                 }
                 dst += 2;
               } else {
-                if (has_mbyte)
+                c = utf_ptr2char(s);
-                  c = mb_ptr2char(s);
-                else
-                  c = *s;
 
                 if (func_one != (fptr_T)NULL)
                   /* Turbo C complains without the typecast */

src/nvim/regexp_nfa.c

@@ -5030,16 +5030,8 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
    * Run for each character.
    */
   for (;; ) {
-    int curc;
+    int curc = utf_ptr2char(reginput);
-    int clen;
+    int clen = utfc_ptr2len(reginput);
-
-    if (has_mbyte) {
-      curc = (*mb_ptr2char)(reginput);
-      clen = (*mb_ptr2len)(reginput);
-    } else {
-      curc = *reginput;
-      clen = 1;
-    }
     if (curc == NUL) {
       clen = 0;
       go_to_nextline = false;
@@ -5501,7 +5493,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
           // We don't care about the order of composing characters.
           // Get them into cchars[] first.
           while (len < clen) {
-            mc = mb_ptr2char(reginput + len);
+            mc = utf_ptr2char(reginput + len);
             cchars[ccount++] = mc;
             len += mb_char2len(mc);
             if (ccount == MAX_MCO)

src/nvim/search.c

@@ -1120,8 +1120,8 @@ int do_search(
       msgbuf = xmalloc(STRLEN(p) + 40);
       {
         msgbuf[0] = dirc;
-        if (enc_utf8 && utf_iscomposing(utf_ptr2char(p))) {
+        if (utf_iscomposing(utf_ptr2char(p))) {
-          /* Use a space to draw the composing char on. */
+          // Use a space to draw the composing char on.
           msgbuf[1] = ' ';
           STRCPY(msgbuf + 2, p);
         } else

src/nvim/spell.c

@@ -1956,7 +1956,7 @@ static int count_syllables(slang_T *slang, char_u *word)
       skip = false;
     } else {
       // No recognized syllable item, at least a syllable char then?
-      c = mb_ptr2char(p);
+      c = utf_ptr2char(p);
       len = (*mb_ptr2len)(p);
       if (vim_strchr(slang->sl_syllable, c) == NULL)
         skip = false;               // No, search for next syllable
@@ -2271,7 +2271,7 @@ static void use_midword(slang_T *lp, win_T *wp)
       int c, l, n;
       char_u  *bp;
 
-      c = mb_ptr2char(p);
+      c = utf_ptr2char(p);
       l = (*mb_ptr2len)(p);
       if (c < 256 && l <= 2)
         wp->w_s->b_spell_ismw[c] = true;
@@ -2597,16 +2597,18 @@ static bool spell_iswordp(char_u *p, win_T *wp)
       if (wp->w_s->b_spell_ismw[*p])
         s = p + 1;                      // skip a mid-word character
     } else {
-      c = mb_ptr2char(p);
+      c = utf_ptr2char(p);
       if (c < 256 ? wp->w_s->b_spell_ismw[c]
           : (wp->w_s->b_spell_ismw_mb != NULL
-             && vim_strchr(wp->w_s->b_spell_ismw_mb, c) != NULL))
+             && vim_strchr(wp->w_s->b_spell_ismw_mb, c) != NULL)) {
         s = p + l;
+      }
     }
 
-    c = mb_ptr2char(s);
+    c = utf_ptr2char(s);
-    if (c > 255)
+    if (c > 255) {
       return spell_mb_isword_class(mb_get_class(s), wp);
+    }
     return spelltab.st_isw[c];
   }
 
@@ -2617,16 +2619,11 @@ static bool spell_iswordp(char_u *p, win_T *wp)
 // Unlike spell_iswordp() this doesn't check for "midword" characters.
 bool spell_iswordp_nmw(const char_u *p, win_T *wp)
 {
-  int c;
+  int c = utf_ptr2char(p);
-
+  if (c > 255) {
-  if (has_mbyte) {
+    return spell_mb_isword_class(mb_get_class(p), wp);
-    c = mb_ptr2char(p);
-    if (c > 255) {
-      return spell_mb_isword_class(mb_get_class(p), wp);
-    }
-    return spelltab.st_isw[c];
   }
-  return spelltab.st_isw[*p];
+  return spelltab.st_isw[c];
 }
 
 // Returns true if word class indicates a word character.
@@ -4300,14 +4297,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                     && utf_iscomposing(utf_ptr2char(fword
                                                     + sp->ts_fcharstart))) {
                   sp->ts_score -= SCORE_SUBST - SCORE_SUBCOMP;
-                } else if (!soundfold
+                } else if (
-                           && slang->sl_has_map
+                    !soundfold
-                           && similar_chars(slang,
+                    && slang->sl_has_map
-                                            mb_ptr2char(tword
+                    && similar_chars(
-                                                        + sp->ts_twordlen
+                        slang,
-                                                        - sp->ts_tcharlen),
+                        utf_ptr2char(tword + sp->ts_twordlen - sp->ts_tcharlen),
-                                            mb_ptr2char(fword
+                        utf_ptr2char(fword + sp->ts_fcharstart))) {
-                                                        + sp->ts_fcharstart))) {
                   // For a similar character adjust score from
                   // SCORE_SUBST to SCORE_SIMILAR.
                   sp->ts_score -= SCORE_SUBST - SCORE_SIMILAR;
@@ -4315,8 +4311,8 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
               } else if (sp->ts_isdiff == DIFF_INSERT
                          && sp->ts_twordlen > sp->ts_tcharlen) {
                 p = tword + sp->ts_twordlen - sp->ts_tcharlen;
-                c = mb_ptr2char(p);
+                c = utf_ptr2char(p);
-                if (enc_utf8 && utf_iscomposing(c)) {
+                if (utf_iscomposing(c)) {
                   // Inserting a composing char doesn't
                   // count that much.
                   sp->ts_score -= SCORE_INS - SCORE_INSCOMP;
@@ -4327,7 +4323,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                   // tree (might seem illogical but does
                   // give better scores).
                   MB_PTR_BACK(tword, p);
-                  if (c == mb_ptr2char(p)) {
+                  if (c == utf_ptr2char(p)) {
                     sp->ts_score -= SCORE_INS - SCORE_INSDUP;
                   }
                 }
@@ -4388,19 +4384,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         // score if the same character is following "nn" -> "n".  It's
         // a bit illogical for soundfold tree but it does give better
         // results.
-        if (has_mbyte) {
+        c = utf_ptr2char(fword + sp->ts_fidx);
-          c = mb_ptr2char(fword + sp->ts_fidx);
+        stack[depth].ts_fidx += MB_PTR2LEN(fword + sp->ts_fidx);
-          stack[depth].ts_fidx += MB_PTR2LEN(fword + sp->ts_fidx);
+        if (utf_iscomposing(c)) {
-          if (enc_utf8 && utf_iscomposing(c)) {
+          stack[depth].ts_score -= SCORE_DEL - SCORE_DELCOMP;
-            stack[depth].ts_score -= SCORE_DEL - SCORE_DELCOMP;
+        } else if (c == utf_ptr2char(fword + stack[depth].ts_fidx)) {
-          } else if (c == mb_ptr2char(fword + stack[depth].ts_fidx)) {
+          stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
-            stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
-          }
-        } else {
-          ++stack[depth].ts_fidx;
-          if (fword[sp->ts_fidx] == fword[sp->ts_fidx + 1])
-            stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
         }
+
         break;
       }
     // FALLTHROUGH
@@ -4515,22 +4506,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         break;
       }
 
-      if (has_mbyte) {
+      n = MB_CPTR2LEN(p);
-        n = MB_CPTR2LEN(p);
+      c = utf_ptr2char(p);
-        c = mb_ptr2char(p);
+      if (p[n] == NUL) {
-        if (p[n] == NUL)
+        c2 = NUL;
-          c2 = NUL;
+      } else if (!soundfold && !spell_iswordp(p + n, curwin)) {
-        else if (!soundfold && !spell_iswordp(p + n, curwin))
+        c2 = c;  // don't swap non-word char
-          c2 = c;           // don't swap non-word char
-        else
-          c2 = mb_ptr2char(p + n);
       } else {
-        if (p[1] == NUL)
+        c2 = utf_ptr2char(p + n);
-          c2 = NUL;
-        else if (!soundfold && !spell_iswordp(p + 1, curwin))
-          c2 = c;           // don't swap non-word char
-        else
-          c2 = p[1];
       }
 
       // When the second character is NUL we can't swap.
@@ -4550,9 +4533,10 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
       if (c2 != NUL && TRY_DEEPER(su, stack, depth, SCORE_SWAP)) {
         go_deeper(stack, depth, SCORE_SWAP);
 #ifdef DEBUG_TRIEWALK
-        sprintf(changename[depth], "%.*s-%s: swap %c and %c",
+        snprintf(changename[depth], sizeof(changename[0]),
-            sp->ts_twordlen, tword, fword + sp->ts_fidx,
+                 "%.*s-%s: swap %c and %c",
-            c, c2);
+                 sp->ts_twordlen, tword, fword + sp->ts_fidx,
+                 c, c2);
 #endif
         PROF_STORE(sp->ts_state)
         sp->ts_state = STATE_UNSWAP;
@@ -4576,38 +4560,25 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
     case STATE_UNSWAP:
       // Undo the STATE_SWAP swap: "21" -> "12".
       p = fword + sp->ts_fidx;
-      if (has_mbyte) {
+      n = MB_PTR2LEN(p);
-        n = MB_PTR2LEN(p);
+      c = utf_ptr2char(p + n);
-        c = mb_ptr2char(p + n);
+      memmove(p + MB_PTR2LEN(p + n), p, n);
-        memmove(p + MB_PTR2LEN(p + n), p, n);
+      mb_char2bytes(c, p);
-        mb_char2bytes(c, p);
+
-      } else {
-        c = *p;
-        *p = p[1];
-        p[1] = c;
-      }
     // FALLTHROUGH
 
     case STATE_SWAP3:
       // Swap two bytes, skipping one: "123" -> "321".  We change
       // "fword" here, it's changed back afterwards at STATE_UNSWAP3.
       p = fword + sp->ts_fidx;
-      if (has_mbyte) {
+      n = MB_CPTR2LEN(p);
-        n = MB_CPTR2LEN(p);
+      c = utf_ptr2char(p);
-        c = mb_ptr2char(p);
+      fl = MB_CPTR2LEN(p + n);
-        fl = MB_CPTR2LEN(p + n);
+      c2 = utf_ptr2char(p + n);
-        c2 = mb_ptr2char(p + n);
+      if (!soundfold && !spell_iswordp(p + n + fl, curwin)) {
-        if (!soundfold && !spell_iswordp(p + n + fl, curwin))
+        c3 = c;  // don't swap non-word char
-          c3 = c;               // don't swap non-word char
-        else
-          c3 = mb_ptr2char(p + n + fl);
       } else {
-        c = *p;
+        c3 = utf_ptr2char(p + n + fl);
-        c2 = p[1];
-        if (!soundfold && !spell_iswordp(p + 2, curwin))
-          c3 = c;               // don't swap non-word char
-        else
-          c3 = p[2];
       }
 
       // When characters are identical: "121" then SWAP3 result is
@@ -4651,22 +4622,15 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
     case STATE_UNSWAP3:
       // Undo STATE_SWAP3: "321" -> "123"
       p = fword + sp->ts_fidx;
-      if (has_mbyte) {
+      n = MB_PTR2LEN(p);
-        n = MB_PTR2LEN(p);
+      c2 = utf_ptr2char(p + n);
-        c2 = mb_ptr2char(p + n);
+      fl = MB_PTR2LEN(p + n);
-        fl = MB_PTR2LEN(p + n);
+      c = utf_ptr2char(p + n + fl);
-        c = mb_ptr2char(p + n + fl);
+      tl = MB_PTR2LEN(p + n + fl);
-        tl = MB_PTR2LEN(p + n + fl);
+      memmove(p + fl + tl, p, n);
-        memmove(p + fl + tl, p, n);
+      mb_char2bytes(c, p);
-        mb_char2bytes(c, p);
+      mb_char2bytes(c2, p + tl);
-        mb_char2bytes(c2, p + tl);
+      p = p + tl;
-        p = p + tl;
-      } else {
-        c = *p;
-        *p = p[2];
-        p[2] = c;
-        ++p;
-      }
 
       if (!soundfold && !spell_iswordp(p, curwin)) {
         // Middle char is not a word char, skip the rotate.  First and
@@ -4690,21 +4654,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         sp->ts_state = STATE_UNROT3L;
         ++depth;
         p = fword + sp->ts_fidx;
-        if (has_mbyte) {
+        n = MB_CPTR2LEN(p);
-          n = MB_CPTR2LEN(p);
+        c = utf_ptr2char(p);
-          c = mb_ptr2char(p);
+        fl = MB_CPTR2LEN(p + n);
-          fl = MB_CPTR2LEN(p + n);
+        fl += MB_CPTR2LEN(p + n + fl);
-          fl += MB_CPTR2LEN(p + n + fl);
+        memmove(p, p + n, fl);
-          memmove(p, p + n, fl);
+        utf_char2bytes(c, p + fl);
-          mb_char2bytes(c, p + fl);
+        stack[depth].ts_fidxtry = sp->ts_fidx + n + fl;
-          stack[depth].ts_fidxtry = sp->ts_fidx + n + fl;
-        } else {
-          c = *p;
-          *p = p[1];
-          p[1] = p[2];
-          p[2] = c;
-          stack[depth].ts_fidxtry = sp->ts_fidx + 3;
-        }
       } else {
         PROF_STORE(sp->ts_state)
         sp->ts_state = STATE_REP_INI;
@@ -4714,19 +4670,12 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
     case STATE_UNROT3L:
       // Undo ROT3L: "231" -> "123"
       p = fword + sp->ts_fidx;
-      if (has_mbyte) {
+      n = MB_PTR2LEN(p);
-        n = MB_PTR2LEN(p);
+      n += MB_PTR2LEN(p + n);
-        n += MB_PTR2LEN(p + n);
+      c = utf_ptr2char(p + n);
-        c = mb_ptr2char(p + n);
+      tl = MB_PTR2LEN(p + n);
-        tl = MB_PTR2LEN(p + n);
+      memmove(p + tl, p, n);
-        memmove(p + tl, p, n);
+      mb_char2bytes(c, p);
-        mb_char2bytes(c, p);
-      } else {
-        c = p[2];
-        p[2] = p[1];
-        p[1] = *p;
-        *p = c;
-      }
 
       // Rotate three bytes right: "123" -> "312".  We change "fword"
       // here, it's changed back afterwards at STATE_UNROT3R.
@@ -4742,21 +4691,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         sp->ts_state = STATE_UNROT3R;
         ++depth;
         p = fword + sp->ts_fidx;
-        if (has_mbyte) {
+        n = MB_CPTR2LEN(p);
-          n = MB_CPTR2LEN(p);
+        n += MB_CPTR2LEN(p + n);
-          n += MB_CPTR2LEN(p + n);
+        c = utf_ptr2char(p + n);
-          c = mb_ptr2char(p + n);
+        tl = MB_CPTR2LEN(p + n);
-          tl = MB_CPTR2LEN(p + n);
+        memmove(p + tl, p, n);
-          memmove(p + tl, p, n);
+        mb_char2bytes(c, p);
-          mb_char2bytes(c, p);
+        stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
-          stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
-        } else {
-          c = p[2];
-          p[2] = p[1];
-          p[1] = *p;
-          *p = c;
-          stack[depth].ts_fidxtry = sp->ts_fidx + 3;
-        }
       } else {
         PROF_STORE(sp->ts_state)
         sp->ts_state = STATE_REP_INI;
@@ -4766,19 +4707,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
     case STATE_UNROT3R:
       // Undo ROT3R: "312" -> "123"
       p = fword + sp->ts_fidx;
-      if (has_mbyte) {
+      c = utf_ptr2char(p);
-        c = mb_ptr2char(p);
+      tl = MB_PTR2LEN(p);
-        tl = MB_PTR2LEN(p);
+      n = MB_PTR2LEN(p + tl);
-        n = MB_PTR2LEN(p + tl);
+      n += MB_PTR2LEN(p + tl + n);
-        n += MB_PTR2LEN(p + tl + n);
+      memmove(p, p + tl, n);
-        memmove(p, p + tl, n);
+      mb_char2bytes(c, p + n);
-        mb_char2bytes(c, p + n);
+
-      } else {
-        c = *p;
-        *p = p[1];
-        p[1] = p[2];
-        p[2] = c;
-      }
     // FALLTHROUGH
 
     case STATE_REP_INI:
@@ -5604,25 +5539,29 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
   if (c1 >= 256) {
     buf[mb_char2bytes(c1, buf)] = 0;
     hi = hash_find(&slang->sl_map_hash, buf);
-    if (HASHITEM_EMPTY(hi))
+    if (HASHITEM_EMPTY(hi)) {
       m1 = 0;
-    else
+    } else {
-      m1 = mb_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
+      m1 = utf_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
-  } else
+    }
+  } else {
     m1 = slang->sl_map_array[c1];
-  if (m1 == 0)
+  }
+  if (m1 == 0) {
     return false;
-
+  }
 
   if (c2 >= 256) {
     buf[mb_char2bytes(c2, buf)] = 0;
     hi = hash_find(&slang->sl_map_hash, buf);
-    if (HASHITEM_EMPTY(hi))
+    if (HASHITEM_EMPTY(hi)) {
       m2 = 0;
-    else
+    } else {
-      m2 = mb_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
+      m2 = utf_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
-  } else
+    }
+  } else {
     m2 = slang->sl_map_array[c2];
+  }
 
   return m1 == m2;
 }
@@ -5659,11 +5598,9 @@ add_suggestion (
       break;
     MB_PTR_BACK(goodword, pgood);
     MB_PTR_BACK(su->su_badptr, pbad);
-    if (has_mbyte) {
+    if (utf_ptr2char(pgood) != utf_ptr2char(pbad)) {
-      if (mb_ptr2char(pgood) != mb_ptr2char(pbad))
-        break;
-    } else if (*pgood != *pbad)
       break;
+    }
   }
 
   if (badlen == 0 && goodlen == 0)
@@ -7608,5 +7545,3 @@ int expand_spelling(linenr_T lnum, char_u *pat, char_u ***matchp)
   *matchp = ga.ga_data;
   return ga.ga_len;
 }
-
-

src/nvim/syntax.c

@@ -4101,13 +4101,9 @@ get_syn_options(
         return NULL;
       }
     } else if (flagtab[fidx].argtype == 11 && arg[5] == '=')   {
-      /* cchar=? */
+      // cchar=?
-      if (has_mbyte) {
+      *conceal_char = utf_ptr2char(arg + 6);
-        *conceal_char = mb_ptr2char(arg + 6);
+      arg += mb_ptr2len(arg + 6) - 1;
-        arg += mb_ptr2len(arg + 6) - 1;
-      } else {
-        *conceal_char = arg[6];
-      }
       if (!vim_isprintc_strict(*conceal_char)) {
         EMSG(_("E844: invalid cchar value"));
         return NULL;

src/nvim/window.c

@@ -5609,7 +5609,7 @@ int match_add(win_T *wp, const char *const grp, const char *const pat,
   m->match.rmm_maxcol = 0;
   m->conceal_char = 0;
   if (conceal_char != NULL) {
-    m->conceal_char = (*mb_ptr2char)((const char_u *)conceal_char);
+    m->conceal_char = utf_ptr2char((const char_u *)conceal_char);
   }
 
   // Set up position matches