From 54ff21a15303e1c7dbfde4895c3444daad6df16a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Linse?= <bjorn.linse@gmail.com>
Date: Sun, 14 Nov 2021 13:34:59 +0100
Subject: [PATCH 1/2] refactor(macros): delete multibyte macros which just are
 aliases

---
 src/nvim/change.c      |  2 +-
 src/nvim/diff.c        |  2 +-
 src/nvim/edit.c        | 10 +++++-----
 src/nvim/eval/funcs.c  | 14 +++++++-------
 src/nvim/file_search.c |  4 ++--
 src/nvim/getchar.c     |  4 ++--
 src/nvim/keymap.c      |  2 +-
 src/nvim/macros.h      |  8 --------
 src/nvim/mbyte.c       | 10 +++++-----
 src/nvim/path.c        | 14 +++++++-------
 src/nvim/plines.c      |  2 +-
 src/nvim/regexp.c      | 15 ++++++++-------
 src/nvim/regexp_nfa.c  | 24 +++++++++++++-----------
 src/nvim/screen.c      |  6 +++---
 src/nvim/search.c      | 10 +++++-----
 src/nvim/spell.c       | 40 ++++++++++++++++++++--------------------
 src/nvim/spellfile.c   |  8 ++++----
 17 files changed, 85 insertions(+), 90 deletions(-)

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 7e70eee75c..6ec4979dac 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -778,7 +778,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
         col = n;
         count = utf_ptr2len(oldp + n);
         n += count;
-      } while (UTF_COMPOSINGLIKE(oldp + col, oldp + n));
+      } while (utf_composinglike(oldp + col, oldp + n));
       fixpos = false;
     }
   }
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 1cc9399465..4e03f4761c 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -744,7 +744,7 @@ static int diff_write_buffer(buf_T *buf, diffin_T *din)
         char_u cbuf[MB_MAXBYTES + 1];
 
         // xdiff doesn't support ignoring case, fold-case the text.
-        int c = PTR2CHAR(s);
+        int c = utf_ptr2char(s);
         c = utf_fold(c);
         const int orig_len = utfc_ptr2len(s);
         if (utf_char2bytes(c, cbuf) != orig_len) {
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index c3d6b8721c..593ba4e843 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -708,7 +708,7 @@ static int insert_execute(VimState *state, int key)
 
         if (str != NULL) {
           for (p = str; *p != NUL; MB_PTR_ADV(p)) {
-            ins_compl_addleader(PTR2CHAR(p));
+            ins_compl_addleader(utf_ptr2char(p));
           }
           xfree(str);
         } else {
@@ -1283,7 +1283,7 @@ normalchar:
         if (*str != NUL && stop_arrow() != FAIL) {
           // Insert the new value of v:char literally.
           for (p = str; *p != NUL; MB_PTR_ADV(p)) {
-            s->c = PTR2CHAR(p);
+            s->c = utf_ptr2char(p);
             if (s->c == CAR || s->c == K_KENTER || s->c == NL) {
               ins_eol(s->c);
             } else {
@@ -3547,7 +3547,7 @@ static void ins_compl_addfrommatch(void)
     }
   }
   p += len;
-  c = PTR2CHAR(p);
+  c = utf_ptr2char(p);
   ins_compl_addleader(c);
 }
 
@@ -5177,10 +5177,10 @@ static int ins_complete(int c, bool enable_pum)
         char_u *p = line + startcol;
 
         MB_PTR_BACK(line, p);
-        while (p > line && vim_isfilec(PTR2CHAR(p))) {
+        while (p > line && vim_isfilec(utf_ptr2char(p))) {
           MB_PTR_BACK(line, p);
         }
-        if (p == line && vim_isfilec(PTR2CHAR(p))) {
+        if (p == line && vim_isfilec(utf_ptr2char(p))) {
           startcol = 0;
         } else {
           startcol = (int)(p - line) + 1;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index e8c84eb9d1..38068f03a9 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -10628,7 +10628,7 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       break;
     }
     charidx--;
-    byteidx += MB_CPTR2LEN((const char_u *)str + byteidx);
+    byteidx += utf_ptr2len((const char_u *)str + byteidx);
   }
 }
 
@@ -10745,7 +10745,7 @@ static void f_strcharpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (!error) {
     if (nchar > 0) {
       while (nchar > 0 && (size_t)nbyte < slen) {
-        nbyte += MB_CPTR2LEN((const char_u *)p + nbyte);
+        nbyte += utf_ptr2len((const char_u *)p + nbyte);
         nchar--;
       }
     } else {
@@ -10761,7 +10761,7 @@ static void f_strcharpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       if (off < 0) {
         len += 1;
       } else {
-        len += (size_t)MB_CPTR2LEN((const char_u *)p + off);
+        len += (size_t)utf_ptr2len((const char_u *)p + off);
       }
       charlen--;
     }
@@ -11739,14 +11739,14 @@ static void f_trim(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (dir == 0 || dir == 1) {
     // Trim leading characters
     while (*head != NUL) {
-      c1 = PTR2CHAR(head);
+      c1 = utf_ptr2char(head);
       if (mask == NULL) {
         if (c1 > ' ' && c1 != 0xa0) {
           break;
         }
       } else {
         for (p = mask; *p != NUL; MB_PTR_ADV(p)) {
-          if (c1 == PTR2CHAR(p)) {
+          if (c1 == utf_ptr2char(p)) {
             break;
           }
         }
@@ -11764,14 +11764,14 @@ static void f_trim(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     for (; tail > head; tail = prev) {
       prev = tail;
       MB_PTR_BACK(head, prev);
-      c1 = PTR2CHAR(prev);
+      c1 = utf_ptr2char(prev);
       if (mask == NULL) {
         if (c1 > ' ' && c1 != 0xa0) {
           break;
         }
       } else {
         for (p = mask; *p != NUL; MB_PTR_ADV(p)) {
-          if (c1 == PTR2CHAR(p)) {
+          if (c1 == utf_ptr2char(p)) {
             break;
           }
         }
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 9b0caa8da0..36257fefb3 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -1113,8 +1113,8 @@ static bool ff_wc_equal(char_u *s1, char_u *s2)
   }
 
   for (i = 0, j = 0; s1[i] != NUL && s2[j] != NUL;) {
-    c1 = PTR2CHAR(s1 + i);
-    c2 = PTR2CHAR(s2 + j);
+    c1 = utf_ptr2char(s1 + i);
+    c2 = utf_ptr2char(s2 + j);
 
     if ((p_fic ? mb_tolower(c1) != mb_tolower(c2) : c1 != c2)
         && (prev1 != '*' || prev2 != '*')) {
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 613b4f5e4d..5267b313c7 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -3996,8 +3996,8 @@ char_u *vim_strsave_escape_csi(char_u *p)
     } else {
       // Add character, possibly multi-byte to destination, escaping
       // CSI and K_SPECIAL. Be careful, it can be an illegal byte!
-      d = add_char2buf(PTR2CHAR(s), d);
-      s += MB_CPTR2LEN(s);
+      d = add_char2buf(utf_ptr2char(s), d);
+      s += utf_ptr2len(s);
     }
   }
   *d = NUL;
diff --git a/src/nvim/keymap.c b/src/nvim/keymap.c
index 81e5cf6ed5..abf016b832 100644
--- a/src/nvim/keymap.c
+++ b/src/nvim/keymap.c
@@ -692,7 +692,7 @@ int find_special_key(const char_u **srcp, const size_t src_len, int *const modp,
           l = utfc_ptr2len(last_dash + 1);
         }
         if (modifiers != 0 && last_dash[l + 1] == '>') {
-          key = PTR2CHAR(last_dash + off);
+          key = utf_ptr2char(last_dash + off);
         } else {
           key = get_special_key_code(last_dash + off);
           if (!keep_x_key) {
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index 8a969c43a1..b315c06656 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -92,14 +92,11 @@
 
 #define REPLACE_NORMAL(s) (((s) & REPLACE_FLAG) && !((s) & VREPLACE_FLAG))
 
-#define UTF_COMPOSINGLIKE(p1, p2)  utf_composinglike((p1), (p2))
-
 // MB_PTR_ADV(): advance a pointer to the next character, taking care of
 // multi-byte characters if needed.
 // MB_PTR_BACK(): backup a pointer to the previous character, taking care of
 // multi-byte characters if needed.
 // MB_COPY_CHAR(f, t): copy one char from "f" to "t" and advance the pointers.
-// PTR2CHAR(): get character from pointer.
 
 // Advance multi-byte pointer, skip over composing chars.
 #define MB_PTR_ADV(p)      (p += utfc_ptr2len((char_u *)p))
@@ -108,14 +105,9 @@
 // Backup multi-byte pointer. Only use with "p" > "s" !
 #define MB_PTR_BACK(s, p) \
   (p -= utf_head_off((char_u *)s, (char_u *)p - 1) + 1)
-// get length of multi-byte char, not including composing chars
-#define MB_CPTR2LEN(p)     utf_ptr2len(p)
 
 #define MB_COPY_CHAR(f, t) mb_copy_char((const char_u **)(&f), &t);
 
-#define MB_CHARLEN(p)      mb_charlen(p)
-#define PTR2CHAR(p)        utf_ptr2char(p)
-
 #define RESET_BINDING(wp) \
   do { \
     (wp)->w_p_scb = false; \
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index b10e33d0c2..3916117785 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -762,7 +762,7 @@ int utfc_ptr2char(const char_u *p, int *pcc)
   // Only accept a composing char when the first char isn't illegal.
   if ((len > 1 || *p < 0x80)
       && p[len] >= 0x80
-      && UTF_COMPOSINGLIKE(p, p + len)) {
+      && utf_composinglike(p, p + len)) {
     cc = utf_ptr2char(p + len);
     for (;; ) {
       pcc[i++] = cc;
@@ -792,7 +792,7 @@ int utfc_ptr2char(const char_u *p, int *pcc)
 int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
 {
 #define IS_COMPOSING(s1, s2, s3) \
-  (i == 0 ? UTF_COMPOSINGLIKE((s1), (s2)) : utf_iscomposing((s3)))
+  (i == 0 ? utf_composinglike((s1), (s2)) : utf_iscomposing((s3)))
 
   assert(maxlen > 0);
 
@@ -914,7 +914,7 @@ int utfc_ptr2len(const char_u *const p)
   // skip all of them (otherwise the cursor would get stuck).
   int prevlen = 0;
   for (;;) {
-    if (p[len] < 0x80 || !UTF_COMPOSINGLIKE(p + prevlen, p + len)) {
+    if (p[len] < 0x80 || !utf_composinglike(p + prevlen, p + len)) {
       return len;
     }
 
@@ -964,14 +964,14 @@ int utfc_ptr2len_len(const char_u *p, int size)
 
     /*
      * Next character length should not go beyond size to ensure that
-     * UTF_COMPOSINGLIKE(...) does not read beyond size.
+     * utf_composinglike(...) does not read beyond size.
      */
     len_next_char = utf_ptr2len_len(p + len, size - len);
     if (len_next_char > size - len) {
       break;
     }
 
-    if (!UTF_COMPOSINGLIKE(p + prevlen, p + len)) {
+    if (!utf_composinglike(p + prevlen, p + len)) {
       break;
     }
 
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 6f0f715a25..1085f7a10c 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -359,8 +359,8 @@ int path_fnamencmp(const char *const fname1, const char *const fname2, size_t le
   const char *p1 = fname1;
   const char *p2 = fname2;
   while (len > 0) {
-    c1 = PTR2CHAR((const char_u *)p1);
-    c2 = PTR2CHAR((const char_u *)p2);
+    c1 = utf_ptr2char((const char_u *)p1);
+    c2 = utf_ptr2char((const char_u *)p2);
     if ((c1 == NUL || c2 == NUL
          || (!((c1 == '/' || c1 == '\\') && (c2 == '\\' || c2 == '/'))))
         && (p_fic ? (c1 != c2 && CH_FOLD(c1) != CH_FOLD(c2)) : c1 != c2)) {
@@ -631,7 +631,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
                && (vim_strchr((char_u *)"*?[{~$", *path_end) != NULL
 #ifndef WIN32
                    || (!p_fic && (flags & EW_ICASE)
-                       && isalpha(PTR2CHAR(path_end)))
+                       && isalpha(utf_ptr2char(path_end)))
 #endif
                    )) {
       e = p;
@@ -1937,8 +1937,8 @@ int pathcmp(const char *p, const char *q, int maxlen)
   const char *s = NULL;
 
   for (i = 0, j = 0; maxlen < 0 || (i < maxlen && j < maxlen);) {
-    c1 = PTR2CHAR((char_u *)p + i);
-    c2 = PTR2CHAR((char_u *)q + j);
+    c1 = utf_ptr2char((char_u *)p + i);
+    c2 = utf_ptr2char((char_u *)q + j);
 
     // End of "p": check if "q" also ends or just has a slash.
     if (c1 == NUL) {
@@ -1980,8 +1980,8 @@ int pathcmp(const char *p, const char *q, int maxlen)
     return 0;
   }
 
-  c1 = PTR2CHAR((char_u *)s + i);
-  c2 = PTR2CHAR((char_u *)s + i + utfc_ptr2len((char_u *)s + i));
+  c1 = utf_ptr2char((char_u *)s + i);
+  c2 = utf_ptr2char((char_u *)s + i + utfc_ptr2len((char_u *)s + i));
   // ignore a trailing slash, but not "//" or ":/"
   if (c2 == NUL
       && i > 0
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index ed28521d80..a061f76f34 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -424,7 +424,7 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
         col %= numberextra;
       }
       if (*sbr != NUL) {
-        sbrlen = (colnr_T)MB_CHARLEN(sbr);
+        sbrlen = (colnr_T)mb_charlen(sbr);
         if (col >= sbrlen) {
           col -= sbrlen;
         }
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index b1c1e49f61..bec3bc9648 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -2509,8 +2509,9 @@ do_multibyte:
           /* Need to get composing character too. */
           for (;; ) {
             l = utf_ptr2len(regparse);
-            if (!UTF_COMPOSINGLIKE(regparse, regparse + l))
+            if (!utf_composinglike(regparse, regparse + l)) {
               break;
+            }
             regmbc(utf_ptr2char(regparse));
             skipchr();
           }
@@ -4127,7 +4128,7 @@ static bool regmatch(
           break;
 
         case PRINT:
-          if (!vim_isprintc(PTR2CHAR(rex.input))) {
+          if (!vim_isprintc(utf_ptr2char(rex.input))) {
             status = RA_NOMATCH;
           } else {
             ADVANCE_REGINPUT();
@@ -4135,7 +4136,7 @@ static bool regmatch(
           break;
 
         case SPRINT:
-          if (ascii_isdigit(*rex.input) || !vim_isprintc(PTR2CHAR(rex.input))) {
+          if (ascii_isdigit(*rex.input) || !vim_isprintc(utf_ptr2char(rex.input))) {
             status = RA_NOMATCH;
           } else {
             ADVANCE_REGINPUT();
@@ -4294,7 +4295,7 @@ static bool regmatch(
             // Check for following composing character, unless %C
             // follows (skips over all composing chars).
             if (status != RA_NOMATCH
-                && UTF_COMPOSINGLIKE(rex.input, rex.input + len)
+                && utf_composinglike(rex.input, rex.input + len)
                 && !rex.reg_icombine
                 && OP(next) != RE_COMPOSING) {
               // raaron: This code makes a composing character get
@@ -5269,7 +5270,7 @@ regrepeat (
   case SIDENT:
   case SIDENT + ADD_NL:
     while (count < maxcount) {
-      if (vim_isIDc(PTR2CHAR(scan)) && (testval || !ascii_isdigit(*scan))) {
+      if (vim_isIDc(utf_ptr2char(scan)) && (testval || !ascii_isdigit(*scan))) {
         MB_PTR_ADV(scan);
       } else if (*scan == NUL) {
         if (!REG_MULTI || !WITH_NL(OP(p)) || rex.lnum > rex.reg_maxline
@@ -5326,7 +5327,7 @@ regrepeat (
   case SFNAME:
   case SFNAME + ADD_NL:
     while (count < maxcount) {
-      if (vim_isfilec(PTR2CHAR(scan)) && (testval || !ascii_isdigit(*scan))) {
+      if (vim_isfilec(utf_ptr2char(scan)) && (testval || !ascii_isdigit(*scan))) {
         MB_PTR_ADV(scan);
       } else if (*scan == NUL) {
         if (!REG_MULTI || !WITH_NL(OP(p)) || rex.lnum > rex.reg_maxline
@@ -5364,7 +5365,7 @@ regrepeat (
         if (got_int) {
           break;
         }
-      } else if (vim_isprintc(PTR2CHAR(scan)) == 1
+      } else if (vim_isprintc(utf_ptr2char(scan)) == 1
                  && (testval || !ascii_isdigit(*scan))) {
         MB_PTR_ADV(scan);
       } else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) {
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index fbaf619620..5df5cc5975 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -1310,9 +1310,10 @@ static int nfa_regatom(void)
       return FAIL;
     }
     for (lp = reg_prev_sub; *lp != NUL; MB_CPTR_ADV(lp)) {
-      EMIT(PTR2CHAR(lp));
-      if (lp != reg_prev_sub)
+      EMIT(utf_ptr2char(lp));
+      if (lp != reg_prev_sub) {
         EMIT(NFA_CONCAT);
+      }
     }
     EMIT(NFA_NOPEN);
     break;
@@ -1722,9 +1723,10 @@ collection:
           }
         }
 
-        /* Normal printable char */
-        if (startc == -1)
-          startc = PTR2CHAR(regparse);
+        // Normal printable char
+        if (startc == -1) {
+          startc = utf_ptr2char(regparse);
+        }
 
         /* Previous char was '-', so this char is end of range. */
         if (emit_range) {
@@ -4996,9 +4998,9 @@ static long find_match_text(colnr_T startcol, int regstart, char_u *match_text)
     char_u *s2 = rex.line + col + regstart_len;  // skip regstart
     while (*s1) {
       int c1_len = PTR2LEN(s1);
-      int c1 = PTR2CHAR(s1);
+      int c1 = utf_ptr2char(s1);
       int c2_len = PTR2LEN(s2);
-      int c2 = PTR2CHAR(s2);
+      int c2 = utf_ptr2char(s2);
 
       if ((c1 != c2 && (!rex.reg_ic || utf_fold(c1) != utf_fold(c2)))
           || c1_len != c2_len) {
@@ -5010,7 +5012,7 @@ static long find_match_text(colnr_T startcol, int regstart, char_u *match_text)
     }
     if (match
         // check that no composing char follows
-        && !utf_iscomposing(PTR2CHAR(s2))) {
+        && !utf_iscomposing(utf_ptr2char(s2))) {
       cleanup_subexpr();
       if (REG_MULTI) {
         rex.reg_startpos[0].lnum = rex.lnum;
@@ -5808,12 +5810,12 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
         break;
 
       case NFA_PRINT:           //  \p
-        result = vim_isprintc(PTR2CHAR(rex.input));
+        result = vim_isprintc(utf_ptr2char(rex.input));
         ADD_STATE_IF_MATCH(t->state);
         break;
 
       case NFA_SPRINT:          //  \P
-        result = !ascii_isdigit(curc) && vim_isprintc(PTR2CHAR(rex.input));
+        result = !ascii_isdigit(curc) && vim_isprintc(utf_ptr2char(rex.input));
         ADD_STATE_IF_MATCH(t->state);
         break;
 
@@ -6306,7 +6308,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
           } else {
             // Checking if the required start character matches is
             // cheaper than adding a state that won't match.
-            const int c = PTR2CHAR(rex.input + clen);
+            const int c = utf_ptr2char(rex.input + clen);
             if (c != prog->regstart
                 && (!rex.reg_ic
                     || utf_fold(c) != utf_fold(prog->regstart))) {
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 5c5466ed28..63e904079e 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -2944,7 +2944,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
           if (wp->w_skipcol == 0 || !wp->w_p_wrap) {
             need_showbreak = false;
           }
-          vcol_sbr = vcol + MB_CHARLEN(sbr);
+          vcol_sbr = vcol + mb_charlen(sbr);
           // Correct end of highlighted area for 'showbreak',
           // required when 'linebreak' is also set.
           if (tocol == vcol) {
@@ -3582,7 +3582,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
           // We have just drawn the showbreak value, no need to add
           // space for it again.
           if (vcol == vcol_sbr) {
-            n_extra -= MB_CHARLEN(get_showbreak_value(wp));
+            n_extra -= mb_charlen(get_showbreak_value(wp));
             if (n_extra < 0) {
               n_extra = 0;
             }
@@ -3678,7 +3678,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
           // Only adjust the tab_len, when at the first column after the
           // showbreak value was drawn.
           if (*sbr != NUL && vcol == vcol_sbr && wp->w_p_wrap) {
-            vcol_adjusted = vcol - MB_CHARLEN(sbr);
+            vcol_adjusted = vcol - mb_charlen(sbr);
           }
           // tab amount depends on current column
           tab_len = tabstop_padding(vcol_adjusted,
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 6c4f17787f..0756fbf37d 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1871,7 +1871,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           --pos.col;
         }
         for (;; ) {
-          initc = PTR2CHAR(linep + pos.col);
+          initc = utf_ptr2char(linep + pos.col);
           if (initc == NUL) {
             break;
           }
@@ -2197,7 +2197,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
      *   inquote if the number of quotes in a line is even, unless this
      *   line or the previous one ends in a '\'.  Complicated, isn't it?
      */
-    const int c = PTR2CHAR(linep + pos.col);
+    const int c = utf_ptr2char(linep + pos.col);
     switch (c) {
     case NUL:
       // at end of line without trailing backslash, reset inquote
@@ -2378,12 +2378,12 @@ void showmatch(int c)
    * Only show match for chars in the 'matchpairs' option.
    */
   // 'matchpairs' is "x:y,x:y"
-  for (p = curbuf->b_p_mps; *p != NUL; ++p) {
-    if (PTR2CHAR(p) == c && (curwin->w_p_rl ^ p_ri)) {
+  for (p = curbuf->b_p_mps; *p != NUL; p++) {
+    if (utf_ptr2char(p) == c && (curwin->w_p_rl ^ p_ri)) {
       break;
     }
     p += utfc_ptr2len(p) + 1;
-    if (PTR2CHAR(p) == c && !(curwin->w_p_rl ^ p_ri)) {
+    if (utf_ptr2char(p) == c && !(curwin->w_p_rl ^ p_ri)) {
       break;
     }
     p += utfc_ptr2len(p);
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 094a160e7f..20081bce4f 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -397,7 +397,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
     bool this_upper = false;  // init for gcc
 
     if (use_camel_case) {
-      c = PTR2CHAR(mi.mi_fend);
+      c = utf_ptr2char(mi.mi_fend);
       this_upper = SPELL_ISUPPER(c);
     }
 
@@ -405,7 +405,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
       MB_PTR_ADV(mi.mi_fend);
       if (use_camel_case) {
         const bool prev_upper = this_upper;
-        c = PTR2CHAR(mi.mi_fend);
+        c = utf_ptr2char(mi.mi_fend);
         this_upper = SPELL_ISUPPER(c);
         camel_case = !prev_upper && this_upper;
       }
@@ -414,7 +414,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
 
     if (capcol != NULL && *capcol == 0 && wp->w_s->b_cap_prog != NULL) {
       // Check word starting with capital letter.
-      c = PTR2CHAR(ptr);
+      c = utf_ptr2char(ptr);
       if (!SPELL_ISUPPER(c)) {
         wrongcaplen = (size_t)(mi.mi_fend - ptr);
       }
@@ -2423,7 +2423,7 @@ int captype(char_u *word, char_u *end)
   // But a word with an upper char only at start is a ONECAP.
   for (; end == NULL ? *p != NUL : p < end; MB_PTR_ADV(p)) {
     if (spell_iswordp_nmw(p, curwin)) {
-      c = PTR2CHAR(p);
+      c = utf_ptr2char(p);
       if (!SPELL_ISUPPER(c)) {
         // UUl -> KEEPCAP
         if (past_second && allcap) {
@@ -2464,7 +2464,7 @@ static int badword_captype(char_u *word, char_u *end)
     l = u = 0;
     first = false;
     for (p = word; p < end; MB_PTR_ADV(p)) {
-      c = PTR2CHAR(p);
+      c = utf_ptr2char(p);
       if (SPELL_ISUPPER(c)) {
         ++u;
         if (p == word) {
@@ -3314,7 +3314,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   // If the word is not capitalised and spell_check() doesn't consider the
   // word to be bad then it might need to be capitalised.  Add a suggestion
   // for that.
-  c = PTR2CHAR(su->su_badptr);
+  c = utf_ptr2char(su->su_badptr);
   if (!SPELL_ISUPPER(c) && attr == HLF_COUNT) {
     make_case_word(su->su_badword, buf, WF_ONECAP);
     add_suggestion(su, &su->su_ga, buf, su->su_badlen, SCORE_ICASE,
@@ -4609,7 +4609,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         break;
       }
 
-      n = MB_CPTR2LEN(p);
+      n = utf_ptr2len(p);
       c = utf_ptr2char(p);
       if (p[n] == NUL) {
         c2 = NUL;
@@ -4669,9 +4669,9 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
       // Swap two bytes, skipping one: "123" -> "321".  We change
       // "fword" here, it's changed back afterwards at STATE_UNSWAP3.
       p = fword + sp->ts_fidx;
-      n = MB_CPTR2LEN(p);
+      n = utf_ptr2len(p);
       c = utf_ptr2char(p);
-      fl = MB_CPTR2LEN(p + n);
+      fl = utf_ptr2len(p + n);
       c2 = utf_ptr2char(p + n);
       if (!soundfold && !spell_iswordp(p + n + fl, curwin)) {
         c3 = c;  // don't swap non-word char
@@ -4746,10 +4746,10 @@ 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;
-        n = MB_CPTR2LEN(p);
+        n = utf_ptr2len(p);
         c = utf_ptr2char(p);
-        fl = MB_CPTR2LEN(p + n);
-        fl += MB_CPTR2LEN(p + n + fl);
+        fl = utf_ptr2len(p + n);
+        fl += utf_ptr2len(p + n + fl);
         memmove(p, p + n, fl);
         utf_char2bytes(c, p + fl);
         stack[depth].ts_fidxtry = sp->ts_fidx + n + fl;
@@ -4783,10 +4783,10 @@ 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;
-        n = MB_CPTR2LEN(p);
-        n += MB_CPTR2LEN(p + n);
+        n = utf_ptr2len(p);
+        n += utf_ptr2len(p + n);
         c = utf_ptr2char(p + n);
-        tl = MB_CPTR2LEN(p + n);
+        tl = utf_ptr2len(p + n);
         memmove(p + tl, p, n);
         utf_char2bytes(c, p);
         stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
@@ -5021,8 +5021,8 @@ static void find_keepcap_word(slang_T *slang, char_u *fword, char_u *kword)
     } else {
       // round[depth] == 1: Try using the folded-case character.
       // round[depth] == 2: Try using the upper-case character.
-      flen = MB_CPTR2LEN(fword + fwordidx[depth]);
-      ulen = MB_CPTR2LEN(uword + uwordidx[depth]);
+      flen = utf_ptr2len(fword + fwordidx[depth]);
+      ulen = utf_ptr2len(uword + uwordidx[depth]);
       if (round[depth] == 1) {
         p = fword + fwordidx[depth];
         l = flen;
@@ -5512,9 +5512,9 @@ badword:
         // lower to upper case.  Helps for "tath" -> "Kath", which is
         // less common than "tath" -> "path".  Don't do it when the
         // letter is the same, that has already been counted.
-        gc = PTR2CHAR(p);
+        gc = utf_ptr2char(p);
         if (SPELL_ISUPPER(gc)) {
-          bc = PTR2CHAR(su->su_badword);
+          bc = utf_ptr2char(su->su_badword);
           if (!SPELL_ISUPPER(bc)
               && SPELL_TOFOLD(bc) != SPELL_TOFOLD(gc)) {
             goodscore += SCORE_ICASE / 2;
@@ -7185,7 +7185,7 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
 
   // If the word starts with a lower-case letter make the word with an
   // upper-case letter in word_up[].
-  c = PTR2CHAR(word);
+  c = utf_ptr2char(word);
   if (SPELL_TOUPPER(c) != c) {
     onecap_copy(word, word_up, true);
     has_word_up = true;
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 1227cd5adc..7e8c24b1bf 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -2508,15 +2508,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                 NUL) {
               int c, c_up;
 
-              c = PTR2CHAR(aff_entry->ae_chop);
+              c = utf_ptr2char(aff_entry->ae_chop);
               c_up = SPELL_TOUPPER(c);
               if (c_up != c
                   && (aff_entry->ae_cond == NULL
-                      || PTR2CHAR(aff_entry->ae_cond) == c)) {
+                      || utf_ptr2char(aff_entry->ae_cond) == c)) {
                 p = aff_entry->ae_add
                     + STRLEN(aff_entry->ae_add);
                 MB_PTR_BACK(aff_entry->ae_add, p);
-                if (PTR2CHAR(p) == c_up) {
+                if (utf_ptr2char(p) == c_up) {
                   upper = true;
                   aff_entry->ae_chop = NULL;
                   *p = NUL;
@@ -3501,7 +3501,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
               if (ae->ae_chop != NULL) {
                 // Remove chop string.
                 p = newword + STRLEN(newword);
-                i = (int)MB_CHARLEN(ae->ae_chop);
+                i = (int)mb_charlen(ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_BACK(newword, p);
                 }

From 1450a6f7534147e3d7252594cf06e2a1cc14b79b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Linse?= <bjorn.linse@gmail.com>
Date: Sun, 14 Nov 2021 13:39:14 +0100
Subject: [PATCH 2/2] refactor(macroman): get rid of MB_COPY_CHAR macro

clean up docs for MB_PTR_ADV and MB_PTR_BACK
---
 src/nvim/eval.c       |  6 +++---
 src/nvim/eval/funcs.c |  2 +-
 src/nvim/ex_docmd.c   |  4 ++--
 src/nvim/macros.h     | 15 ++++++---------
 src/nvim/mbyte.c      |  5 +----
 src/nvim/spellfile.c  |  2 +-
 src/nvim/strings.c    |  2 +-
 7 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index b27a11c248..0123c7265b 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -4969,11 +4969,11 @@ static int get_string_tv(char_u **arg, typval_T *rettv, int evaluate)
         FALLTHROUGH;
 
       default:
-        MB_COPY_CHAR(p, name);
+        mb_copy_char((const char_u **)&p, &name);
         break;
       }
     } else {
-      MB_COPY_CHAR(p, name);
+      mb_copy_char((const char_u **)&p, &name);
     }
   }
   *name = NUL;
@@ -5033,7 +5033,7 @@ static int get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate)
       }
       ++p;
     }
-    MB_COPY_CHAR(p, str);
+    mb_copy_char((const char_u **)&p, &str);
   }
   *str = NUL;
   *arg = p + 1;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 38068f03a9..1d9ebdb596 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -10761,7 +10761,7 @@ static void f_strcharpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       if (off < 0) {
         len += 1;
       } else {
-        len += (size_t)utf_ptr2len((const char_u *)p + off);
+        len += utf_ptr2len((const char_u *)p + off);
       }
       charlen--;
     }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index ecff9becdf..499c6ed4f9 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2565,7 +2565,7 @@ static void append_command(char_u *cmd)
       STRCPY(d, "<a0>");
       d += 4;
     } else {
-      MB_COPY_CHAR(s, d);
+      mb_copy_char((const char_u **)&s, &d);
     }
   }
   *d = NUL;
@@ -5806,7 +5806,7 @@ static char_u *uc_split_args(char_u *arg, size_t *lenp)
       *q++ = ',';
       *q++ = '"';
     } else {
-      MB_COPY_CHAR(p, q);
+      mb_copy_char((const char_u **)&p, &q);
     }
   }
   *q++ = '"';
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index b315c06656..faef0f69b2 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -92,22 +92,19 @@
 
 #define REPLACE_NORMAL(s) (((s) & REPLACE_FLAG) && !((s) & VREPLACE_FLAG))
 
-// MB_PTR_ADV(): advance a pointer to the next character, taking care of
-// multi-byte characters if needed.
-// MB_PTR_BACK(): backup a pointer to the previous character, taking care of
-// multi-byte characters if needed.
-// MB_COPY_CHAR(f, t): copy one char from "f" to "t" and advance the pointers.
 
-// Advance multi-byte pointer, skip over composing chars.
+// MB_PTR_ADV(): advance a pointer to the next character, taking care of
+// multi-byte characters if needed. Skip over composing chars.
 #define MB_PTR_ADV(p)      (p += utfc_ptr2len((char_u *)p))
+
 // Advance multi-byte pointer, do not skip over composing chars.
 #define MB_CPTR_ADV(p)     (p += utf_ptr2len(p))
-// Backup multi-byte pointer. Only use with "p" > "s" !
+
+// MB_PTR_BACK(): backup a pointer to the previous character, taking care of
+// multi-byte characters if needed. Only use with "p" > "s" !
 #define MB_PTR_BACK(s, p) \
   (p -= utf_head_off((char_u *)s, (char_u *)p - 1) + 1)
 
-#define MB_COPY_CHAR(f, t) mb_copy_char((const char_u **)(&f), &t);
-
 #define RESET_BINDING(wp) \
   do { \
     (wp)->w_p_scb = false; \
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 3916117785..12460646ed 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -791,9 +791,6 @@ int utfc_ptr2char(const char_u *p, int *pcc)
  */
 int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
 {
-#define IS_COMPOSING(s1, s2, s3) \
-  (i == 0 ? utf_composinglike((s1), (s2)) : utf_iscomposing((s3)))
-
   assert(maxlen > 0);
 
   int i = 0;
@@ -809,7 +806,7 @@ int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
       int len_cc = utf_ptr2len_len(p + len, maxlen - len);
       safe = len_cc > 1 && len_cc <= maxlen - len;
       if (!safe || (pcc[i] = utf_ptr2char(p + len)) < 0x80
-          || !IS_COMPOSING(p, p + len, pcc[i])) {
+          || !(i == 0 ? utf_composinglike(p, p+len) : utf_iscomposing(pcc[i]))) {
         break;
       }
       len += len_cc;
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 7e8c24b1bf..0fc9012f27 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -3501,7 +3501,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
               if (ae->ae_chop != NULL) {
                 // Remove chop string.
                 p = newword + STRLEN(newword);
-                i = (int)mb_charlen(ae->ae_chop);
+                i = mb_charlen(ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_BACK(newword, p);
                 }
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index e08f73ef6c..47cbf01996 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -283,7 +283,7 @@ char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_n
       continue;
     }
 
-    MB_COPY_CHAR(p, d);
+    mb_copy_char(&p, &d);
   }
 
   // add terminating quote and finish with a NUL