refactor: replace char_u with char 22 (#21786)

Work on https://github.com/neovim/neovim/issues/459

54 files changed, 532 insertions, 535 deletions

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 3f93d85624..bc0bd9e004 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -3829,7 +3829,7 @@ static int chk_modeline(linenr_T lnum, int flags)
             && (s[0] != 'V'
                 || strncmp(skipwhite(e + 1), "set", 3) == 0)
             && (s[3] == ':'
-                || (VIM_VERSION_100 >= vers && isdigit(s[3]))
+                || (VIM_VERSION_100 >= vers && isdigit((uint8_t)s[3]))
                 || (VIM_VERSION_100 < vers && s[3] == '<')
                 || (VIM_VERSION_100 > vers && s[3] == '>')
                 || (VIM_VERSION_100 == vers && s[3] == '='))) {
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index aa2d845728..fa9aa27774 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -146,19 +146,19 @@ int buf_init_chartab(buf_T *buf, int global)
   // options Each option is a list of characters, character numbers or
   // ranges, separated by commas, e.g.: "200-210,x,#-178,-"
   for (i = global ? 0 : 3; i <= 3; i++) {
-    const char_u *p;
+    const char *p;
     if (i == 0) {
       // first round: 'isident'
-      p = (char_u *)p_isi;
+      p = p_isi;
     } else if (i == 1) {
       // second round: 'isprint'
-      p = (char_u *)p_isp;
+      p = p_isp;
     } else if (i == 2) {
       // third round: 'isfname'
-      p = (char_u *)p_isf;
+      p = p_isf;
     } else {  // i == 3
       // fourth round: 'iskeyword'
-      p = (char_u *)buf->b_p_isk;
+      p = buf->b_p_isk;
     }
 
     while (*p) {
@@ -254,8 +254,8 @@ int buf_init_chartab(buf_T *buf, int global)
         c++;
       }
 
-      c = *p;
-      p = (char_u *)skip_to_option_part((char *)p);
+      c = (uint8_t)(*p);
+      p = skip_to_option_part(p);
 
       if ((c == ',') && (*p == NUL)) {
         // Trailing comma is not allowed.
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index b5956d75ab..59891e9899 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -1174,7 +1174,7 @@ static bool expand_showtail(expand_T *xp)
     // separator, on DOS the '*' "path\*\file" must not be skipped.
     if (rem_backslash(s)) {
       s++;
-    } else if (vim_strchr("*?[", *s) != NULL) {
+    } else if (vim_strchr("*?[", (uint8_t)(*s)) != NULL) {
       return false;
     }
   }
@@ -1405,7 +1405,7 @@ static const char *set_cmd_index(const char *cmd, exarg_T *eap, expand_T *xp, in
       }
     }
     // check for non-alpha command
-    if (p == cmd && vim_strchr("@*!=><&~#", *p) != NULL) {
+    if (p == cmd && vim_strchr("@*!=><&~#", (uint8_t)(*p)) != NULL) {
       p++;
     }
     len = (size_t)(p - cmd);
@@ -1435,7 +1435,7 @@ static const char *set_cmd_index(const char *cmd, exarg_T *eap, expand_T *xp, in
   }
 
   if (eap->cmdidx == CMD_SIZE) {
-    if (*cmd == 's' && vim_strchr("cgriI", cmd[1]) != NULL) {
+    if (*cmd == 's' && vim_strchr("cgriI", (uint8_t)cmd[1]) != NULL) {
       eap->cmdidx = CMD_substitute;
       p = cmd + 1;
     } else if (cmd[0] >= 'A' && cmd[0] <= 'Z') {
@@ -2171,7 +2171,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
 
   // 1. skip comment lines and leading space, colons or bars
   const char *cmd;
-  for (cmd = buff; vim_strchr(" \t:|", *cmd) != NULL; cmd++) {}
+  for (cmd = buff; vim_strchr(" \t:|", (uint8_t)(*cmd)) != NULL; cmd++) {}
   xp->xp_pattern = (char *)cmd;
 
   if (*cmd == NUL) {
@@ -2967,7 +2967,7 @@ static void expand_shellcmd(char *filepat, char ***matches, int *numMatches, int
     path = ".";
   } else {
     // For an absolute name we don't use $PATH.
-    if (!path_is_absolute((char_u *)pat)) {
+    if (!path_is_absolute(pat)) {
       path = vim_getenv("PATH");
     }
     if (path == NULL) {
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index d12ac87bbb..2df82d9355 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -280,7 +280,7 @@ static HistoryType get_histtype(const char *const name, const size_t len, const
     }
   }
 
-  if (vim_strchr(":=@>?/", name[0]) != NULL && len == 1) {
+  if (vim_strchr(":=@>?/", (uint8_t)name[0]) != NULL && len == 1) {
     return hist_char2type(name[0]);
   }
 
@@ -437,7 +437,7 @@ int clr_history(const int histype)
 /// Remove all entries matching {str} from a history.
 ///
 /// @param histype  may be one of the HIST_ values.
-static int del_history_entry(int histype, char_u *str)
+static int del_history_entry(int histype, char *str)
 {
   if (hislen == 0 || histype < 0 || histype >= HIST_COUNT || *str == NUL
       || hisidx[histype] < 0) {
@@ -446,7 +446,7 @@ static int del_history_entry(int histype, char_u *str)
 
   const int idx = hisidx[histype];
   regmatch_T regmatch;
-  regmatch.regprog = vim_regcomp((char *)str, RE_MAGIC + RE_STRING);
+  regmatch.regprog = vim_regcomp(str, RE_MAGIC + RE_STRING);
   if (regmatch.regprog == NULL) {
     return false;
   }
@@ -560,7 +560,7 @@ void f_histdel(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     // string given: remove all matching entries
     char buf[NUMBUFLEN];
     n = del_history_entry(get_histtype(str, strlen(str), false),
-                          (char_u *)tv_get_string_buf(&argvars[1], buf));
+                          (char *)tv_get_string_buf(&argvars[1], buf));
   }
   rettv->vval.v_number = n;
 }
@@ -611,7 +611,7 @@ void ex_history(exarg_T *eap)
   int idx;
   int i, j, k;
   char *end;
-  char_u *arg = (char_u *)eap->arg;
+  char *arg = eap->arg;
 
   if (hislen == 0) {
     msg(_("'history' option is zero"));
@@ -619,12 +619,12 @@ void ex_history(exarg_T *eap)
   }
 
   if (!(ascii_isdigit(*arg) || *arg == '-' || *arg == ',')) {
-    end = (char *)arg;
+    end = arg;
     while (ASCII_ISALPHA(*end)
-           || vim_strchr(":=@>/?", *end) != NULL) {
+           || vim_strchr(":=@>/?", (uint8_t)(*end)) != NULL) {
       end++;
     }
-    histype1 = get_histtype((const char *)arg, (size_t)(end - (char *)arg), false);
+    histype1 = get_histtype(arg, (size_t)(end - arg), false);
     if (histype1 == HIST_INVALID) {
       if (STRNICMP(arg, "all", end - (char *)arg) == 0) {
         histype1 = 0;
@@ -637,7 +637,7 @@ void ex_history(exarg_T *eap)
       histype2 = histype1;
     }
   } else {
-    end = (char *)arg;
+    end = arg;
   }
   if (!get_list_range(&end, &hisidx1, &hisidx2) || *end != NUL) {
     semsg(_(e_trailing_arg), end);
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 45f00cb41e..40be6b1abc 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -1575,7 +1575,7 @@ static bool extract_hunk(FILE *fd, diffhunk_T *hunk, diffstyle_T *diffstyle)
       // --- file1       2018-03-20 13:23:35.783153140 +0100
       // +++ file2       2018-03-20 13:23:41.183156066 +0100
       // @@ -1,3 +1,5 @@
-      if (isdigit(*line)) {
+      if (isdigit((uint8_t)(*line))) {
         *diffstyle = DIFF_ED;
       } else if ((strncmp(line, "@@ ", 3) == 0)) {
         *diffstyle = DIFF_UNIFIED;
@@ -1593,7 +1593,7 @@ static bool extract_hunk(FILE *fd, diffhunk_T *hunk, diffstyle_T *diffstyle)
     }
 
     if (*diffstyle == DIFF_ED) {
-      if (!isdigit(*line)) {
+      if (!isdigit((uint8_t)(*line))) {
         continue;   // not the start of a diff block
       }
       if (parse_diff_ed(line, hunk) == FAIL) {
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 33038dfb9f..144817fe2b 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1885,7 +1885,7 @@ static int get_digraph_chars(const typval_T *arg, int *char1, int *char2)
 {
   char buf_chars[NUMBUFLEN];
   const char *chars = tv_get_string_buf_chk(arg, buf_chars);
-  const char_u *p = (const char_u *)chars;
+  const char *p = chars;
 
   if (p != NULL) {
     if (*p != NUL) {
@@ -1917,7 +1917,7 @@ static bool digraph_set_common(const typval_T *argchars, const typval_T *argdigr
   if (digraph == NULL) {
     return false;
   }
-  const char_u *p = (const char_u *)digraph;
+  const char *p = digraph;
   int n = mb_cptr2char_adv(&p);
   if (*p != NUL) {
     semsg(_(e_digraph_argument_must_be_one_character_str), digraph);
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index ae3e5698b2..9287fdb460 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -513,7 +513,7 @@ static bool use_cursor_line_nr(win_T *wp, linenr_T lnum, int row, int startrow,
                  && (wp->w_p_culopt_flags & CULOPT_LINE)));
 }
 
-static inline void get_line_number_str(win_T *wp, linenr_T lnum, char_u *buf, size_t buf_len)
+static inline void get_line_number_str(win_T *wp, linenr_T lnum, char *buf, size_t buf_len)
 {
   long num;
   char *fmt = "%*ld ";
@@ -531,7 +531,7 @@ static inline void get_line_number_str(win_T *wp, linenr_T lnum, char_u *buf, si
     }
   }
 
-  snprintf((char *)buf, buf_len, fmt, number_width(wp), num);
+  snprintf(buf, buf_len, fmt, number_width(wp), num);
 }
 
 static int get_line_number_attr(win_T *wp, linenr_T lnum, int row, int startrow, int filler_lines)
@@ -612,7 +612,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
   int row;                            // row in the window, excl w_winrow
   ScreenGrid *grid = &wp->w_grid;     // grid specific to the window
 
-  char_u extra[57];                   // sign, line number and 'fdc' must
+  char extra[57];                     // sign, line number and 'fdc' must
                                       // fit in here
   int n_extra = 0;                    // number of extra chars
   char *p_extra = NULL;               // string of extra chars, plus NUL
@@ -806,7 +806,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       nextline[SPWORDLEN] = NUL;
       if (lnum < wp->w_buffer->b_ml.ml_line_count) {
         line = ml_get_buf(wp->w_buffer, lnum + 1, false);
-        spell_cat_line(nextline + SPWORDLEN, (char_u *)line, SPWORDLEN);
+        spell_cat_line(nextline + SPWORDLEN, line, SPWORDLEN);
       }
 
       // When a word wrapped from the previous line the start of the current
@@ -1132,7 +1132,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         // no bad word found at line start, don't check until end of a
         // word
         spell_hlf = HLF_COUNT;
-        word_end = (int)(spell_to_word_end((char_u *)ptr, wp) - (char_u *)line + 1);
+        word_end = (int)(spell_to_word_end(ptr, wp) - line + 1);
       } else {
         // bad word found, use attributes until end of word
         assert(len <= INT_MAX);
@@ -1278,7 +1278,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         if (wp->w_scwidth > 0) {
           get_sign_display_info(false, wp, lnum, sattrs, row,
                                 startrow, filler_lines, filler_todo,
-                                &c_extra, &c_final, (char *)extra, sizeof(extra),
+                                &c_extra, &c_final, extra, sizeof(extra),
                                 &p_extra, &n_extra, &char_attr, sign_idx,
                                 sign_cul_attr);
           sign_idx++;
@@ -1303,29 +1303,29 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           if (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u' && num_signs > 0) {
             get_sign_display_info(true, wp, lnum, sattrs, row,
                                   startrow, filler_lines, filler_todo,
-                                  &c_extra, &c_final, (char *)extra, sizeof(extra),
+                                  &c_extra, &c_final, extra, sizeof(extra),
                                   &p_extra, &n_extra, &char_attr, sign_idx,
                                   sign_cul_attr);
           } else {
             // Draw the line number (empty space after wrapping).
             if (row == startrow + filler_lines) {
-              get_line_number_str(wp, lnum, (char_u *)extra, sizeof(extra));
+              get_line_number_str(wp, lnum, extra, sizeof(extra));
               if (wp->w_skipcol > 0) {
-                for (p_extra = (char *)extra; *p_extra == ' '; p_extra++) {
+                for (p_extra = extra; *p_extra == ' '; p_extra++) {
                   *p_extra = '-';
                 }
               }
               if (wp->w_p_rl) {                       // reverse line numbers
                 // like rl_mirror(), but keep the space at the end
-                char *p2 = skipwhite((char *)extra);
+                char *p2 = skipwhite(extra);
                 p2 = skiptowhite(p2) - 1;
-                for (char *p1 = skipwhite((char *)extra); p1 < p2; p1++, p2--) {
+                for (char *p1 = skipwhite(extra); p1 < p2; p1++, p2--) {
                   const char t = *p1;
                   *p1 = *p2;
                   *p2 = t;
                 }
               }
-              p_extra = (char *)extra;
+              p_extra = extra;
               c_extra = NUL;
             } else {
               c_extra = ' ';
@@ -1729,14 +1729,14 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           || (mb_l > 1 && (!vim_isprintc(mb_c)))) {
         // Illegal UTF-8 byte: display as <xx>.
         // Non-BMP character : display as ? or fullwidth ?.
-        transchar_hex((char *)extra, mb_c);
+        transchar_hex(extra, mb_c);
         if (wp->w_p_rl) {  // reverse
-          rl_mirror((char *)extra);
+          rl_mirror(extra);
         }
 
-        p_extra = (char *)extra;
+        p_extra = extra;
         c = (uint8_t)(*p_extra);
-        mb_c = mb_ptr2char_adv((const char_u **)&p_extra);
+        mb_c = mb_ptr2char_adv((const char **)&p_extra);
         mb_utf8 = (c >= 0x80);
         n_extra = (int)strlen(p_extra);
         c_extra = NUL;
@@ -1909,7 +1909,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
               p = prev_ptr;
             }
             cap_col -= (int)(prev_ptr - line);
-            size_t tmplen = spell_check(wp, (char_u *)p, &spell_hlf, &cap_col, nochange);
+            size_t tmplen = spell_check(wp, p, &spell_hlf, &cap_col, nochange);
             assert(tmplen <= INT_MAX);
             len = (int)tmplen;
             word_end = (int)v + len;
@@ -2075,12 +2075,12 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         if (c == TAB && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
           int tab_len = 0;
           long vcol_adjusted = vcol;  // removed showbreak length
-          char_u *const sbr = get_showbreak_value(wp);
+          char *const sbr = (char *)get_showbreak_value(wp);
 
           // 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((char *)sbr);
+            vcol_adjusted = vcol - mb_charlen(sbr);
           }
           // tab amount depends on current column
           tab_len = tabstop_padding((colnr_T)vcol_adjusted,
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 6102f05abd..9b82d50012 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -3127,7 +3127,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
         // make up some named keys <o>, <O>, <e>, <0>, <>>, <<>, <*>,
         // <:> and <!> so that people can re-indent on o, O, e, 0, <,
         // >, *, : and ! keys if they really really want to.
-        if (vim_strchr("<>!*oOe0:", look[1]) != NULL
+        if (vim_strchr("<>!*oOe0:", (uint8_t)look[1]) != NULL
             && keytyped == look[1]) {
           return true;
         }
@@ -3182,7 +3182,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           // TODO(@brammool): multi-byte
           if (keytyped == (int)(uint8_t)p[-1]
               || (icase && keytyped < 256
-                  && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1]))) {
+                  && TOLOWER_LOC(keytyped) == TOLOWER_LOC((uint8_t)p[-1]))) {
             line = get_cursor_pos_ptr();
             assert(p >= look && (uintmax_t)(p - look) <= SIZE_MAX);
             if ((curwin->w_cursor.col == (colnr_T)(p - look)
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 6d32b71016..b0805aecff 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2185,7 +2185,7 @@ int pattern_match(const char *pat, const char *text, bool ic)
   regmatch.regprog = vim_regcomp((char *)pat, RE_MAGIC + RE_STRING);
   if (regmatch.regprog != NULL) {
     regmatch.rm_ic = ic;
-    matches = vim_regexec_nl(&regmatch, (char_u *)text, (colnr_T)0);
+    matches = vim_regexec_nl(&regmatch, (char *)text, (colnr_T)0);
     vim_regfree(regmatch.regprog);
   }
   p_cpo = save_cpo;
@@ -2543,7 +2543,7 @@ static int eval4(char **arg, typval_T *rettv, int evaluate)
       if (p[2] == 'n' && p[3] == 'o' && p[4] == 't') {
         len = 5;
       }
-      if (!isalnum(p[len]) && p[len] != '_') {
+      if (!isalnum((uint8_t)p[len]) && p[len] != '_') {
         type = len == 2 ? EXPR_IS : EXPR_ISNOT;
       }
     }
@@ -3777,7 +3777,7 @@ static int get_string_tv(char **arg, typval_T *rettv, int evaluate)
       case 'U':
         if (ascii_isxdigit(p[1])) {
           int n, nr;
-          int c = toupper(*p);
+          int c = toupper((uint8_t)(*p));
 
           if (c == 'X') {
             n = 2;
@@ -6302,7 +6302,7 @@ int get_id_len(const char **const arg)
       // slice "[n:]". Also "xx:" is not a namespace.
       len = (int)(p - *arg);
       if (len > 1
-          || (len == 1 && vim_strchr(namespace_char, **arg) == NULL)) {
+          || (len == 1 && vim_strchr(namespace_char, (uint8_t)(**arg)) == NULL)) {
         break;
       }
     }
@@ -6430,7 +6430,7 @@ const char *find_name_end(const char *arg, const char **expr_start, const char *
       // slice "[n:]".  Also "xx:" is not a namespace. But {ns}: is.
       len = (int)(p - arg);
       if ((len > 1 && p[-1] != '}')
-          || (len == 1 && vim_strchr(namespace_char, *arg) == NULL)) {
+          || (len == 1 && vim_strchr(namespace_char, (uint8_t)(*arg)) == NULL)) {
         break;
       }
     }
@@ -8081,7 +8081,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, const char
   if (regmatch.regprog != NULL) {
     char *tail = str;
     char *end = str + strlen(str);
-    while (vim_regexec_nl(&regmatch, (char_u *)str, (colnr_T)(tail - str))) {
+    while (vim_regexec_nl(&regmatch, str, (colnr_T)(tail - str))) {
       // Skip empty match except for first match.
       if (regmatch.startp[0] == regmatch.endp[0]) {
         if (zero_width == regmatch.startp[0]) {
diff --git a/src/nvim/eval/executor.c b/src/nvim/eval/executor.c
index 86d6063b01..831c468288 100644
--- a/src/nvim/eval/executor.c
+++ b/src/nvim/eval/executor.c
@@ -69,7 +69,7 @@ int eexe_mod_op(typval_T *const tv1, const typval_T *const tv2, const char *cons
       if (tv2->v_type == VAR_LIST) {
         break;
       }
-      if (vim_strchr("+-*/%", *op) != NULL) {
+      if (vim_strchr("+-*/%", (uint8_t)(*op)) != NULL) {
         // nr += nr  or  nr -= nr, nr *= nr, nr /= nr, nr %= nr
         varnumber_T n = tv_get_number(tv1);
         if (tv2->v_type == VAR_FLOAT) {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index d6b9ca20fc..25e026706c 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1770,7 +1770,7 @@ static void f_expand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
     size_t len;
     char *errormsg = NULL;
-    char *result = (char *)eval_vars((char_u *)s, (char_u *)s, &len, NULL, &errormsg, NULL, false);
+    char *result = (char *)eval_vars((char *)s, (char_u *)s, &len, NULL, &errormsg, NULL, false);
     if (p_verbose == 0) {
       emsg_off--;
     } else if (errormsg != NULL) {
@@ -4488,7 +4488,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
         }
       }
 
-      match = vim_regexec_nl(&regmatch, (char_u *)str, startcol);
+      match = vim_regexec_nl(&regmatch, str, startcol);
 
       if (match && --nth <= 0) {
         break;
@@ -5885,7 +5885,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
           q[-1] = NUL;
           q = path_tail(p);
         }
-        if (q > p && !path_is_absolute((const char_u *)buf)) {
+        if (q > p && !path_is_absolute(buf)) {
           // Symlink is relative to directory of argument. Replace the
           // symlink with the resolved name in the same directory.
           const size_t p_len = strlen(p);
@@ -6228,7 +6228,7 @@ static int search_cmn(typval_T *argvars, pos_T *match_pos, int *flagsp)
   // Repeat until {skip} returns false.
   for (;;) {
     subpatnum
-      = searchit(curwin, curbuf, &pos, NULL, dir, (char_u *)pat, 1, options, RE_SEARCH, &sia);
+      = searchit(curwin, curbuf, &pos, NULL, dir, (char *)pat, 1, options, RE_SEARCH, &sia);
     // finding the first match again means there is no match where {skip}
     // evaluates to zero.
     if (firstpos.lnum != 0 && equalpos(pos, firstpos)) {
@@ -6810,7 +6810,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
       .sa_tm = &tm,
     };
 
-    int n = searchit(curwin, curbuf, &pos, NULL, dir, (char_u *)pat, 1L,
+    int n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L,
                      options, RE_SEARCH, &sia);
     if (n == FAIL || (firstpos.lnum != 0 && equalpos(pos, firstpos))) {
       // didn't find it or found the first match again: FAIL
@@ -7073,7 +7073,7 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
   if (csearch != NULL) {
     int pcc[MAX_MCO];
     const int c = utfc_ptr2char((char *)csearch, pcc);
-    set_last_csearch(c, csearch, utfc_ptr2len((char *)csearch));
+    set_last_csearch(c, (char *)csearch, utfc_ptr2len((char *)csearch));
   }
 
   dictitem_T *di = tv_dict_find(d, S_LEN("forward"));
@@ -7553,7 +7553,7 @@ static void f_spellbadword(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
     if (str != NULL) {
       // Check the argument for spelling.
       while (*str != NUL) {
-        len = spell_check(curwin, (char_u *)str, &attr, &capcol, false);
+        len = spell_check(curwin, (char *)str, &attr, &capcol, false);
         if (attr != HLF_COUNT) {
           word = str;
           break;
@@ -7668,7 +7668,7 @@ static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       if (*str == NUL) {
         match = false;  // Empty item at the end.
       } else {
-        match = vim_regexec_nl(&regmatch, (char_u *)str, col);
+        match = vim_regexec_nl(&regmatch, (char *)str, col);
       }
       const char *end;
       if (match) {
@@ -7930,11 +7930,11 @@ static void strchar_common(typval_T *argvars, typval_T *rettv, bool skipcc)
 {
   const char *s = tv_get_string(&argvars[0]);
   varnumber_T len = 0;
-  int (*func_mb_ptr2char_adv)(const char_u **pp);
+  int (*func_mb_ptr2char_adv)(const char **pp);
 
   func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;