refactor: replace char_u with char 22 (#21786)

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

4 files changed, 27 insertions, 27 deletions

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;
   while (*s != NUL) {
-    func_mb_ptr2char_adv((const char_u **)&s);
+    func_mb_ptr2char_adv(&s);
     len++;
   }
   rettv->vval.v_number = len;
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 1a3fd13fe3..5d3b70b414 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -118,7 +118,7 @@ static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int
       while (ASCII_ISALNUM(*p) || *p == '_') {
         p++;
       }
-      if (arg == p || isdigit(*arg)
+      if (arg == p || isdigit((uint8_t)(*arg))
           || (p - arg == 9 && strncmp(arg, "firstline", 9) == 0)
           || (p - arg == 8 && strncmp(arg, "lastline", 8) == 0)) {
         if (!skip) {
@@ -1228,7 +1228,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
 /// looked up by name.
 static bool func_name_refcount(const char_u *name)
 {
-  return isdigit(*name) || *name == '<';
+  return isdigit((uint8_t)(*name)) || *name == '<';
 }
 
 /// Call a user function after checking the arguments.
@@ -2002,7 +2002,7 @@ static void list_functions(regmatch_T *regmatch)
           && (regmatch == NULL
               ? (!message_filtered((char *)fp->uf_name)
                  && !func_name_refcount((char_u *)fp->uf_name))
-              : (!isdigit(*fp->uf_name)
+              : (!isdigit((uint8_t)(*fp->uf_name))
                  && vim_regexec(regmatch, (char *)fp->uf_name, 0)))) {
         list_func_head(fp, false, false);
         if (changed != func_hashtab.ht_changed) {
@@ -2792,7 +2792,7 @@ void ex_delfunction(exarg_T *eap)
     *p = NUL;
   }
 
-  if (isdigit(*name) && fudi.fd_dict == NULL) {
+  if (isdigit((uint8_t)(*name)) && fudi.fd_dict == NULL) {
     if (!eap->skip) {
       semsg(_(e_invarg2), eap->arg);
     }
@@ -2858,7 +2858,7 @@ void func_unref(char_u *name)
   }
 
   fp = find_func(name);
-  if (fp == NULL && isdigit(*name)) {
+  if (fp == NULL && isdigit((uint8_t)(*name))) {
 #ifdef EXITFREE
     if (!entered_free_all_mem) {
       internal_error("func_unref()");
@@ -2901,7 +2901,7 @@ void func_ref(char_u *name)
   fp = find_func(name);
   if (fp != NULL) {
     (fp->uf_refcount)++;
-  } else if (isdigit(*name)) {
+  } else if (isdigit((uint8_t)(*name))) {
     // Only give an error for a numbered function.
     // Fail silently, when named or lambda function isn't found.
     internal_error("func_ref()");
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 206df03381..75af99fbd5 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -106,7 +106,7 @@ static list_T *heredoc_get(exarg_T *eap, char *cmd)
       return NULL;
     }
     *p = NUL;
-    if (islower(*marker)) {
+    if (islower((uint8_t)(*marker))) {
       emsg(_("E221: Marker cannot start with lower case letter"));
       return NULL;
     }
@@ -208,7 +208,7 @@ static void ex_let_const(exarg_T *eap, const bool is_const)
     argend--;
   }
   expr = skipwhite(argend);
-  if (*expr != '=' && !((vim_strchr("+-*/%.", *expr) != NULL
+  if (*expr != '=' && !((vim_strchr("+-*/%.", (uint8_t)(*expr)) != NULL
                          && expr[1] == '=') || strncmp(expr, "..=", 3) == 0)) {
     // ":let" without "=": list variables
     if (*arg == '[') {
@@ -244,7 +244,7 @@ static void ex_let_const(exarg_T *eap, const bool is_const)
     op[0] = '=';
     op[1] = NUL;
     if (*expr != '=') {
-      if (vim_strchr("+-*/%.", *expr) != NULL) {
+      if (vim_strchr("+-*/%.", (uint8_t)(*expr)) != NULL) {
         op[0] = *expr;  // +=, -=, *=, /=, %= or .=
         if (expr[0] == '.' && expr[1] == '.') {  // ..=
           expr++;
@@ -590,10 +590,10 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
     if (len == 0) {
       semsg(_(e_invarg2), name - 1);
     } else {
-      if (op != NULL && vim_strchr("+-*/%", *op) != NULL) {
+      if (op != NULL && vim_strchr("+-*/%", (uint8_t)(*op)) != NULL) {
         semsg(_(e_letwrong), op);
       } else if (endchars != NULL
-                 && vim_strchr(endchars, *skipwhite(arg)) == NULL) {
+                 && vim_strchr(endchars, (uint8_t)(*skipwhite(arg))) == NULL) {
         emsg(_(e_letunexp));
       } else if (!check_secure()) {
         char *tofree = NULL;
@@ -629,7 +629,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
     char *const p = (char *)find_option_end((const char **)&arg, &scope);
     if (p == NULL
         || (endchars != NULL
-            && vim_strchr(endchars, *skipwhite(p)) == NULL)) {
+            && vim_strchr(endchars, (uint8_t)(*skipwhite(p))) == NULL)) {
       emsg(_(e_letunexp));
     } else {
       varnumber_T n = 0;
@@ -716,10 +716,10 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
       return NULL;
     }
     arg++;
-    if (op != NULL && vim_strchr("+-*/%", *op) != NULL) {
+    if (op != NULL && vim_strchr("+-*/%", (uint8_t)(*op)) != NULL) {
       semsg(_(e_letwrong), op);
     } else if (endchars != NULL
-               && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) {
+               && vim_strchr(endchars, (uint8_t)(*skipwhite(arg + 1))) == NULL) {
       emsg(_(e_letunexp));
     } else {
       char *s;
@@ -747,7 +747,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
 
     char *const p = get_lval(arg, tv, &lv, false, false, 0, FNE_CHECK_START);
     if (p != NULL && lv.ll_name != NULL) {
-      if (endchars != NULL && vim_strchr(endchars, *skipwhite(p)) == NULL) {
+      if (endchars != NULL && vim_strchr(endchars, (uint8_t)(*skipwhite(p))) == NULL) {
         emsg(_(e_letunexp));
       } else {
         set_var_lval(&lv, p, tv, copy, is_const, op);
@@ -1464,7 +1464,7 @@ bool var_wrong_func_name(const char *const name, const bool new_var)
 {
   // Allow for w: b: s: and t:.
   // Allow autoload variable.
-  if (!(vim_strchr("wbst", name[0]) != NULL && name[1] == ':')
+  if (!(vim_strchr("wbst", (uint8_t)name[0]) != NULL && name[1] == ':')
       && !ASCII_ISUPPER((name[0] != NUL && name[1] == ':') ? name[2] : name[0])
       && vim_strchr(name, '#') == NULL) {
     semsg(_("E704: Funcref variable name must start with a capital: %s"), name);