refactor: replace char_u with char

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

1 files changed, 141 insertions, 142 deletions

diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 1b338ef4bf..48c3cd11e2 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -365,8 +365,8 @@ typedef struct affentry_S affentry_T;
 // Affix entry from ".aff" file.  Used for prefixes and suffixes.
 struct affentry_S {
   affentry_T *ae_next;         // next affix with same name/number
-  char_u *ae_chop;         // text to chop off basic word (can be NULL)
-  char_u *ae_add;          // text to add to basic word (can be NULL)
+  char *ae_chop;           // text to chop off basic word (can be NULL)
+  char *ae_add;            // text to add to basic word (can be NULL)
   char_u *ae_flags;        // flags on the affix (can be NULL)
   char_u *ae_cond;         // condition (NULL for ".")
   regprog_T *ae_prog;         // regexp program for ae_cond or NULL
@@ -483,7 +483,7 @@ typedef struct spellinfo_S {
   int si_memtot;                // runtime memory used
   int si_verbose;               // verbose messages
   int si_msg_count;             // number of words added since last message
-  char_u *si_info;         // info text chars or NULL
+  char *si_info;                // info text chars or NULL
   int si_region_count;          // number of regions supported (1 when there
                                 // are no regions)
   char_u si_region_name[MAXREGIONS * 2 + 1];
@@ -493,8 +493,8 @@ typedef struct spellinfo_S {
   garray_T si_rep;              // list of fromto_T entries from REP lines
   garray_T si_repsal;           // list of fromto_T entries from REPSAL lines
   garray_T si_sal;              // list of fromto_T entries from SAL lines
-  char_u *si_sofofr;       // SOFOFROM text
-  char_u *si_sofoto;       // SOFOTO text
+  char *si_sofofr;              // SOFOFROM text
+  char *si_sofoto;              // SOFOTO text
   int si_nosugfile;             // NOSUGFILE item found
   int si_nosplitsugs;           // NOSPLITSUGS item found
   int si_nocompoundsugs;        // NOCOMPOUNDSUGS item found
@@ -504,16 +504,16 @@ typedef struct spellinfo_S {
   time_t si_sugtime;            // timestamp for .sug file
   int si_rem_accents;           // soundsalike: remove accents
   garray_T si_map;              // MAP info concatenated
-  char_u *si_midword;      // MIDWORD chars or NULL
+  char *si_midword;             // MIDWORD chars or NULL
   int si_compmax;               // max nr of words for compounding
   int si_compminlen;            // minimal length for compounding
   int si_compsylmax;            // max nr of syllables for compounding
   int si_compoptions;           // COMP_ flags
   garray_T si_comppat;          // CHECKCOMPOUNDPATTERN items, each stored as
                                 // a string
-  char_u *si_compflags;    // flags used for compounding
+  char *si_compflags;           // flags used for compounding
   char_u si_nobreak;            // NOBREAK
-  char_u *si_syllable;     // syllable string
+  char *si_syllable;            // syllable string
   garray_T si_prefcond;         // table with conditions for postponed
                                 // prefixes, each stored as a string
   int si_newprefID;             // current value for ah_newID
@@ -2046,11 +2046,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   bool found_map = false;
   hashitem_T *hi;
   int l;
-  int compminlen = 0;                   // COMPOUNDMIN value
-  int compsylmax = 0;                   // COMPOUNDSYLMAX value
-  int compoptions = 0;                  // COMP_ flags
-  int compmax = 0;                      // COMPOUNDWORDMAX value
-  char_u *compflags = NULL;        // COMPOUNDFLAG and COMPOUNDRULE
+  int compminlen = 0;              // COMPOUNDMIN value
+  int compsylmax = 0;              // COMPOUNDSYLMAX value
+  int compoptions = 0;             // COMP_ flags
+  int compmax = 0;                 // COMPOUNDWORDMAX value
+  char *compflags = NULL;          // COMPOUNDFLAG and COMPOUNDRULE
                                    // concatenated
   char_u *midword = NULL;          // MIDWORD value
   char_u *syllable = NULL;         // SYLLABLE value
@@ -2179,7 +2179,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
       } else if (spell_info_item(items[0]) && itemcnt > 1) {
         p = getroom(spin,
-                    (spin->si_info == NULL ? 0 : STRLEN(spin->si_info))
+                    (spin->si_info == NULL ? 0 : strlen(spin->si_info))
                     + strlen(items[0])
                     + strlen(items[1]) + 3, false);
         if (spin->si_info != NULL) {
@@ -2189,9 +2189,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         STRCAT(p, items[0]);
         STRCAT(p, " ");
         STRCAT(p, items[1]);
-        spin->si_info = (char_u *)p;
+        spin->si_info = p;
       } else if (is_aff_rule(items, itemcnt, "MIDWORD", 2) && midword == NULL) {
-        midword = (char_u *)getroom_save(spin, (char_u *)items[1]);
+        midword = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "TRY", 2)) {
         // ignored, we look in the tree for what chars may appear
       } else if ((is_aff_rule(items, itemcnt, "RAR", 2)  // TODO(vim): remove "RAR" later
@@ -2253,7 +2253,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         p = getroom(spin, strlen(items[1]) + 2, false);
         STRCPY(p, items[1]);
         STRCAT(p, "+");
-        compflags = (char_u *)p;
+        compflags = p;
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDRULES", 2)) {
         // We don't use the count, but do check that it's a number and
         // not COMPOUNDRULE mistyped.
@@ -2268,7 +2268,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           // using a slash to separate them.
           l = (int)strlen(items[1]) + 1;
           if (compflags != NULL) {
-            l += (int)STRLEN(compflags) + 1;
+            l += (int)strlen(compflags) + 1;
           }
           p = getroom(spin, (size_t)l, false);
           if (compflags != NULL) {
@@ -2276,7 +2276,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             STRCAT(p, "/");
           }
           STRCAT(p, items[1]);
-          compflags = (char_u *)p;
+          compflags = p;
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
                  && compmax == 0) {
@@ -2325,12 +2325,12 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
         if (i >= gap->ga_len) {
           ga_grow(gap, 2);
-          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[1]);
-          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[2]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[1]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[2]);
         }
       } else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
                  && syllable == NULL) {
-        syllable = (char_u *)getroom_save(spin, (char_u *)items[1]);
+        syllable = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "NOBREAK", 1)) {
         spin->si_nobreak = true;
       } else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1)) {
@@ -2394,7 +2394,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                  fname, lnum, items[1]);
           }
           STRCPY(cur_aff->ah_key, items[1]);
-          hash_add(tp, (char_u *)cur_aff->ah_key);
+          hash_add(tp, cur_aff->ah_key);
 
           cur_aff->ah_combine = (*items[2] == 'Y');
         }
@@ -2463,13 +2463,13 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         aff_entry = getroom(spin, sizeof(*aff_entry), true);
 
         if (strcmp(items[2], "0") != 0) {
-          aff_entry->ae_chop = (char_u *)getroom_save(spin, (char_u *)items[2]);
+          aff_entry->ae_chop = getroom_save(spin, items[2]);
         }
         if (strcmp(items[3], "0") != 0) {
-          aff_entry->ae_add = (char_u *)getroom_save(spin, (char_u *)items[3]);
+          aff_entry->ae_add = getroom_save(spin, items[3]);
 
           // Recognize flags on the affix: abcd/XYZ
-          aff_entry->ae_flags = (char_u *)vim_strchr((char *)aff_entry->ae_add, '/');
+          aff_entry->ae_flags = (char_u *)vim_strchr(aff_entry->ae_add, '/');
           if (aff_entry->ae_flags != NULL) {
             *aff_entry->ae_flags++ = NUL;
             aff_process_flags(aff, aff_entry);
@@ -2478,15 +2478,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 
         // Don't use an affix entry with non-ASCII characters when
         // "spin->si_ascii" is true.
-        if (!spin->si_ascii || !(has_non_ascii(aff_entry->ae_chop)
-                                 || has_non_ascii(aff_entry->ae_add))) {
+        if (!spin->si_ascii || !(has_non_ascii((char_u *)aff_entry->ae_chop)
+                                 || has_non_ascii((char_u *)aff_entry->ae_add))) {
           aff_entry->ae_next = cur_aff->ah_first;
           cur_aff->ah_first = aff_entry;
 
           if (strcmp(items[4], ".") != 0) {
             char_u buf[MAXLINELEN];
 
-            aff_entry->ae_cond = (char_u *)getroom_save(spin, (char_u *)items[4]);
+            aff_entry->ae_cond = (char_u *)getroom_save(spin, items[4]);
             if (*items[0] == 'P') {
               sprintf((char *)buf, "^%s", items[4]);  // NOLINT(runtime/printf)
             } else {
@@ -2512,17 +2512,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             // be empty or start with the same letter.
             if (aff_entry->ae_chop != NULL
                 && aff_entry->ae_add != NULL
-                && aff_entry->ae_chop[utfc_ptr2len((char *)aff_entry->ae_chop)] ==
+                && aff_entry->ae_chop[utfc_ptr2len(aff_entry->ae_chop)] ==
                 NUL) {
               int c, c_up;
 
-              c = utf_ptr2char((char *)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
                       || utf_ptr2char((char *)aff_entry->ae_cond) == c)) {
-                p = (char *)aff_entry->ae_add
-                    + STRLEN(aff_entry->ae_add);
+                p = aff_entry->ae_add + strlen(aff_entry->ae_add);
                 MB_PTR_BACK(aff_entry->ae_add, p);
                 if (utf_ptr2char(p) == c_up) {
                   upper = true;
@@ -2535,7 +2534,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                   if (aff_entry->ae_cond != NULL) {
                     char_u buf[MAXLINELEN];
                     onecap_copy((char_u *)items[4], buf, true);
-                    aff_entry->ae_cond = (char_u *)getroom_save(spin, buf);
+                    aff_entry->ae_cond = (char_u *)getroom_save(spin, (char *)buf);
                     if (aff_entry->ae_cond != NULL) {
                       sprintf((char *)buf, "^%s", aff_entry->ae_cond);  // NOLINT(runtime/printf)
                       vim_regfree(aff_entry->ae_prog);
@@ -2563,14 +2562,14 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                 idx = spin->si_prefcond.ga_len;
                 pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
                 *pp = (aff_entry->ae_cond == NULL) ?
-                      NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond);
+                      NULL : (char_u *)getroom_save(spin, (char *)aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
               if (aff_entry->ae_add == NULL) {
                 p = "";
               } else {
-                p = (char *)aff_entry->ae_add;
+                p = aff_entry->ae_add;
               }
 
               // PFX_FLAGS is a negative number, so that
@@ -2637,7 +2636,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           }
           add_fromto(spin, items[0][3] == 'S'
                      ? &spin->si_repsal
-                     : &spin->si_rep, (char_u *)items[1], (char_u *)items[2]);
+                     : &spin->si_rep, items[1], items[2]);
         }
       } else if (is_aff_rule(items, itemcnt, "MAP", 2)) {
         // MAP item or count
@@ -2682,24 +2681,24 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             spin->si_rem_accents = sal_to_bool(items[2]);
           } else {
             // when "to" is "_" it means empty
-            add_fromto(spin, &spin->si_sal, (char_u *)items[1],
-                       strcmp(items[2], "_") == 0 ? (char_u *)""
-                       : (char_u *)items[2]);
+            add_fromto(spin, &spin->si_sal, items[1],
+                       strcmp(items[2], "_") == 0 ? ""
+                       : items[2]);
           }
         }
       } else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
                  && sofofrom == NULL) {
-        sofofrom = (char_u *)getroom_save(spin, (char_u *)items[1]);
+        sofofrom = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
                  && sofoto == NULL) {
-        sofoto = (char_u *)getroom_save(spin, (char_u *)items[1]);
+        sofoto = (char_u *)getroom_save(spin, items[1]);
       } else if (strcmp(items[0], "COMMON") == 0) {
         int i;
 
         for (i = 1; i < itemcnt; i++) {
           if (HASHITEM_EMPTY(hash_find(&spin->si_commonwords, (char *)items[i]))) {
             p = xstrdup(items[i]);
-            hash_add(&spin->si_commonwords, (char_u *)p);
+            hash_add(&spin->si_commonwords, p);
           }
         }
       } else {
@@ -2762,8 +2761,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   }
 
   if (syllable != NULL) {
-    aff_check_string((char *)spin->si_syllable, (char *)syllable, "SYLLABLE");
-    spin->si_syllable = syllable;
+    aff_check_string(spin->si_syllable, (char *)syllable, "SYLLABLE");
+    spin->si_syllable = (char *)syllable;
   }
 
   if (sofofrom != NULL || sofoto != NULL) {
@@ -2773,16 +2772,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     } else if (!GA_EMPTY(&spin->si_sal)) {
       smsg(_("Both SAL and SOFO lines in %s"), fname);
     } else {
-      aff_check_string((char *)spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
-      aff_check_string((char *)spin->si_sofoto, (char *)sofoto, "SOFOTO");
-      spin->si_sofofr = sofofrom;
-      spin->si_sofoto = sofoto;
+      aff_check_string(spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
+      aff_check_string(spin->si_sofoto, (char *)sofoto, "SOFOTO");
+      spin->si_sofofr = (char *)sofofrom;
+      spin->si_sofoto = (char *)sofoto;
     }
   }
 
   if (midword != NULL) {
-    aff_check_string((char *)spin->si_midword, (char *)midword, "MIDWORD");
-    spin->si_midword = midword;
+    aff_check_string(spin->si_midword, (char *)midword, "MIDWORD");
+    spin->si_midword = (char *)midword;
   }
 
   xfree(pc);
@@ -2813,7 +2812,7 @@ static void aff_process_flags(afffile_T *affile, affentry_T *entry)
       prevp = p;
       flag = get_affitem(affile->af_flagtype, &p);
       if (flag == affile->af_comppermit || flag == affile->af_compforbid) {
-        STRMOVE(prevp, p);
+        STRMOVE(prevp, (char *)p);
         p = prevp;
         if (flag == affile->af_comppermit) {
           entry->ae_comppermit = true;
@@ -2896,13 +2895,13 @@ static unsigned get_affitem(int flagtype, char_u **pp)
   return (unsigned)res;
 }
 
-// Process the "compflags" string used in an affix file and append it to
-// spin->si_compflags.
-// The processing involves changing the affix names to ID numbers, so that
-// they fit in one byte.
-static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compflags)
+/// Process the "compflags" string used in an affix file and append it to
+/// spin->si_compflags.
+/// The processing involves changing the affix names to ID numbers, so that
+/// they fit in one byte.
+static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags)
 {
-  char_u *p;
+  char *p;
   char_u *prevp;
   unsigned flag;
   compitem_T *ci;
@@ -2915,9 +2914,9 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
   // Make room for the old and the new compflags, concatenated with a / in
   // between.  Processing it makes it shorter, but we don't know by how
   // much, thus allocate the maximum.
-  len = (int)STRLEN(compflags) + 1;
+  len = (int)strlen(compflags) + 1;
   if (spin->si_compflags != NULL) {
-    len += (int)STRLEN(spin->si_compflags) + 1;
+    len += (int)strlen(spin->si_compflags) + 1;
   }
   p = getroom(spin, (size_t)len, false);
   if (spin->si_compflags != NULL) {
@@ -2925,20 +2924,20 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
     STRCAT(p, "/");
   }
   spin->si_compflags = p;
-  tp = p + STRLEN(p);
+  tp = (char_u *)p + strlen(p);
 
   for (p = compflags; *p != NUL;) {
     if (vim_strchr("/?*+[]", *p) != NULL) {
       // Copy non-flag characters directly.
-      *tp++ = *p++;
+      *tp++ = (char_u)(*p++);
     } else {
       // First get the flag number, also checks validity.
-      prevp = p;
-      flag = get_affitem(aff->af_flagtype, &p);
+      prevp = (char_u *)p;
+      flag = get_affitem(aff->af_flagtype, (char_u **)&p);
       if (flag != 0) {
         // Find the flag in the hashtable.  If it was used before, use
         // the existing ID.  Otherwise add a new entry.
-        STRLCPY(key, prevp, p - prevp + 1);
+        STRLCPY(key, prevp, (char_u *)p - prevp + 1);
         hi = hash_find(&aff->af_comp, (char *)key);
         if (!HASHITEM_EMPTY(hi)) {
           id = HI2CI(hi)->ci_newID;
@@ -2953,7 +2952,7 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
             id = spin->si_newcompID--;
           } while (vim_strchr("/?*+[]\\-^", id) != NULL);
           ci->ci_newID = id;
-          hash_add(&aff->af_comp, ci->ci_key);
+          hash_add(&aff->af_comp, (char *)ci->ci_key);
         }
         *tp++ = (char_u)id;
       }
@@ -3050,17 +3049,17 @@ static bool str_equal(char *s1, char *s2)
   return strcmp(s1, s2) == 0;
 }
 
-// Add a from-to item to "gap".  Used for REP and SAL items.
-// They are stored case-folded.
-static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from, char_u *to)
+/// Add a from-to item to "gap".  Used for REP and SAL items.
+/// They are stored case-folded.
+static void add_fromto(spellinfo_T *spin, garray_T *gap, char *from, char *to)
 {
   char_u word[MAXWLEN];
 
   fromto_T *ftp = GA_APPEND_VIA_PTR(fromto_T, gap);
-  (void)spell_casefold(curwin, from, (int)STRLEN(from), word, MAXWLEN);
-  ftp->ft_from = (char_u *)getroom_save(spin, word);
-  (void)spell_casefold(curwin, to, (int)STRLEN(to), word, MAXWLEN);
-  ftp->ft_to = (char_u *)getroom_save(spin, word);
+  (void)spell_casefold(curwin, (char_u *)from, (int)strlen(from), word, MAXWLEN);
+  ftp->ft_from = (char_u *)getroom_save(spin, (char *)word);
+  (void)spell_casefold(curwin, (char_u *)to, (int)strlen(to), word, MAXWLEN);
+  ftp->ft_to = (char_u *)getroom_save(spin, (char *)word);
 }
 
 /// Converts a boolean argument in a SAL line to true or false;
@@ -3107,13 +3106,13 @@ static void spell_free_aff(afffile_T *aff)
 static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
 {
   hashtab_T ht;
-  char_u line[MAXLINELEN];
+  char line[MAXLINELEN];
   char_u *p;
   char_u *afflist;
   char_u store_afflist[MAXWLEN];
   int pfxlen;
   bool need_affix;
-  char_u *dw;
+  char *dw;
   char_u *pc;
   char_u *w;
   int l;
@@ -3161,7 +3160,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
     }
     // Remove CR, LF and white space from the end.  White space halfway through
     // the word is kept to allow multi-word terms like "et al.".
-    l = (int)STRLEN(line);
+    l = (int)strlen(line);
     while (l > 0 && line[l - 1] <= ' ') {
       l--;
     }
@@ -3181,7 +3180,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
       w = pc;
     } else {
       pc = NULL;
-      w = line;
+      w = (char_u *)line;
     }
 
     // Truncate the word at the "/", set "afflist" to what follows.
@@ -3189,7 +3188,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
     afflist = NULL;
     for (p = w; *p != NUL; MB_PTR_ADV(p)) {
       if (*p == '\\' && (p[1] == '\\' || p[1] == '/')) {
-        STRMOVE(p, p + 1);
+        STRMOVE(p, (char *)p + 1);
       } else if (*p == '/') {
         *p = NUL;
         afflist = p + 1;
@@ -3223,15 +3222,15 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
     }
 
     // Store the word in the hashtable to be able to find duplicates.
-    dw = (char_u *)getroom_save(spin, w);
+    dw = getroom_save(spin, (char *)w);
     if (dw == NULL) {
       retval = FAIL;
       xfree(pc);
       break;
     }
 
-    hash = hash_hash(dw);
-    hi = hash_lookup(&ht, (const char *)dw, STRLEN(dw), hash);
+    hash = hash_hash((char_u *)dw);
+    hi = hash_lookup(&ht, (const char *)dw, strlen(dw), hash);
     if (!HASHITEM_EMPTY(hi)) {
       if (p_verbose > 0) {
         smsg(_("Duplicate word in %s line %d: %s"),
@@ -3242,7 +3241,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
       }
       duplicate++;
     } else {
-      hash_add_item(&ht, hi, dw, hash);
+      hash_add_item(&ht, hi, (char_u *)dw, hash);
     }
 
     flags = 0;
@@ -3427,7 +3426,7 @@ static void get_compflags(afffile_T *affile, char_u *afflist, char_u *store_affl
 /// @param pfxlen  nr of flags in "pfxlist" for prefixes, rest is compound flags
 ///
 /// @return  FAIL when out of memory.
-static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afffile_T *affile,
+static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffile_T *affile,
                           hashtab_T *ht, hashtab_T *xht, int condit, int flags, char_u *pfxlist,
                           int pfxlen)
 {
@@ -3435,7 +3434,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
   hashitem_T *hi;
   affheader_T *ah;
   affentry_T *ae;
-  char_u newword[MAXWLEN];
+  char newword[MAXWLEN];
   int retval = OK;
   int i, j;
   char_u *p;
@@ -3445,7 +3444,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
   bool need_affix;
   char_u store_afflist[MAXWLEN];
   char_u pfx_pfxlist[MAXWLEN];
-  size_t wordlen = STRLEN(word);
+  size_t wordlen = strlen(word);
   int use_condit;
 
   todo = (int)ht->ht_used;
@@ -3475,9 +3474,9 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
                || ae->ae_chop != NULL
                || ae->ae_flags != NULL)
               && (ae->ae_chop == NULL
-                  || STRLEN(ae->ae_chop) < wordlen)
+                  || strlen(ae->ae_chop) < wordlen)
               && (ae->ae_prog == NULL
-                  || vim_regexec_prog(&ae->ae_prog, false, word, (colnr_T)0))
+                  || vim_regexec_prog(&ae->ae_prog, false, (char_u *)word, (colnr_T)0))
               && (((condit & CONDIT_CFIX) == 0)
                   == ((condit & CONDIT_AFF) == 0
                       || ae->ae_flags == NULL
@@ -3491,10 +3490,10 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
               } else {
                 STRLCPY(newword, ae->ae_add, MAXWLEN);
               }
-              p = word;
+              p = (char_u *)word;
               if (ae->ae_chop != NULL) {
                 // Skip chop string.
-                i = mb_charlen(ae->ae_chop);
+                i = mb_charlen((char_u *)ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_ADV(p);
                 }
@@ -3505,8 +3504,8 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
               STRLCPY(newword, word, MAXWLEN);
               if (ae->ae_chop != NULL) {
                 // Remove chop string.
-                p = newword + STRLEN(newword);
-                i = mb_charlen(ae->ae_chop);
+                p = (char_u *)newword + strlen(newword);
+                i = mb_charlen((char_u *)ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_BACK(newword, p);
                 }
@@ -3674,8 +3673,8 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
 {
   FILE *fd;
   long lnum = 0;
-  char_u rline[MAXLINELEN];
-  char_u *line;
+  char rline[MAXLINELEN];
+  char *line;
   char_u *pc = NULL;
   char_u *p;
   int l;
@@ -3706,8 +3705,8 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
     }
 
     // Remove CR, LF and white space from the end.
-    l = (int)STRLEN(rline);
-    while (l > 0 && rline[l - 1] <= ' ') {
+    l = (int)strlen(rline);
+    while (l > 0 && (uint8_t)rline[l - 1] <= ' ') {
       l--;
     }
     if (l == 0) {
@@ -3718,13 +3717,13 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
     // Convert from "/encoding={encoding}" to 'encoding' when needed.
     xfree(pc);
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = (char_u *)string_convert(&spin->si_conv, (char *)rline, NULL);
+      pc = (char_u *)string_convert(&spin->si_conv, rline, NULL);
       if (pc == NULL) {
         smsg(_("Conversion failure for word in %s line %ld: %s"),
              fname, lnum, rline);
         continue;
       }
-      line = pc;
+      line = (char *)pc;
     } else {
       pc = NULL;
       line = rline;
@@ -3744,7 +3743,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
 
           // Setup for conversion to 'encoding'.
           line += 9;
-          enc = enc_canonize((char *)line);
+          enc = enc_canonize(line);
           if (!spin->si_ascii
               && convert_setup(&spin->si_conv, enc, p_enc) == FAIL) {
             smsg(_("Conversion in %s not supported: from %s to %s"),
@@ -3762,11 +3761,11 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
                fname, lnum, line);
         } else {
           line += 8;
-          if (STRLEN(line) > MAXREGIONS * 2) {
+          if (strlen(line) > MAXREGIONS * 2) {
             smsg(_("Too many regions in %s line %ld: %s"),
                  fname, lnum, line);
           } else {
-            spin->si_region_count = (int)STRLEN(line) / 2;
+            spin->si_region_count = (int)strlen(line) / 2;
             STRCPY(spin->si_region_name, line);
 
             // Adjust the mask for a word valid in all regions.
@@ -3785,7 +3784,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
     regionmask = spin->si_region;
 
     // Check for flags and region after a slash.
-    p = (char_u *)vim_strchr((char *)line, '/');
+    p = (char_u *)vim_strchr(line, '/');
     if (p != NULL) {
       *p++ = NUL;
       while (*p != NUL) {
@@ -3818,7 +3817,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
     }
 
     // Skip non-ASCII words when "spin->si_ascii" is true.
-    if (spin->si_ascii && has_non_ascii(line)) {
+    if (spin->si_ascii && has_non_ascii((char_u *)line)) {
       non_ascii++;
       continue;
     }
@@ -3883,9 +3882,9 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
 /// Make a copy of a string into memory allocated with getroom().
 ///
 /// @return  NULL when out of memory.
-static char *getroom_save(spellinfo_T *spin, char_u *s)
+static char *getroom_save(spellinfo_T *spin, char *s)
 {
-  const size_t s_size = STRLEN(s) + 1;
+  const size_t s_size = strlen(s) + 1;
   return memcpy(getroom(spin, s_size, false), s, s_size);
 }
 
@@ -3936,20 +3935,20 @@ static bool valid_spell_word(const char *word, const char *end)
 /// @param region  supported region(s)
 /// @param pfxlist  list of prefix ids or null
 /// @param need_affix  only store word with affix id
-static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, const char_u *pfxlist,
+static int store_word(spellinfo_T *spin, char *word, int flags, int region, const char_u *pfxlist,
                       bool need_affix)
 {
-  int len = (int)STRLEN(word);
-  int ct = captype(word, word + len);
+  int len = (int)strlen(word);
+  int ct = captype((char_u *)word, (char_u *)word + len);
   char_u foldword[MAXWLEN];
   int res = OK;
 
   // Avoid adding illegal bytes to the word tree.
-  if (!valid_spell_word((char *)word, (char *)word + len)) {
+  if (!valid_spell_word(word, word + len)) {
     return FAIL;
   }
 
-  (void)spell_casefold(curwin, word, len, foldword, MAXWLEN);
+  (void)spell_casefold(curwin, (char_u *)word, len, foldword, MAXWLEN);
   for (const char_u *p = pfxlist; res == OK; p++) {
     if (!need_affix || (p != NULL && *p != NUL)) {
       res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
@@ -3964,7 +3963,7 @@ static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, co
   if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
     for (const char_u *p = pfxlist; res == OK; p++) {
       if (!need_affix || (p != NULL && *p != NUL)) {
-        res = tree_add_word(spin, word, spin->si_keeproot, flags,
+        res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags,
                             region, p == NULL ? 0 : *p);
       }
       if (p == NULL || *p == NUL) {
@@ -4268,7 +4267,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
       // Try to find an identical child.
       hash = hash_hash(child->wn_u1.hashkey);
       hi = hash_lookup(ht, (const char *)child->wn_u1.hashkey,
-                       STRLEN(child->wn_u1.hashkey), hash);
+                       strlen((char *)child->wn_u1.hashkey), hash);
       if (!HASHITEM_EMPTY(hi)) {
         // There are children we encountered before with a hash value
         // identical to the current child.  Now check if there is one
@@ -4394,7 +4393,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
   if (spin->si_info != NULL) {
     putc(SN_INFO, fd);                                  // <sectionID>
     putc(0, fd);                                        // <sectionflags>
-    size_t i = STRLEN(spin->si_info);
+    size_t i = strlen(spin->si_info);
     put_bytes(fd, i, 4);                                // <sectionlen>
     fwv &= fwrite(spin->si_info, i, 1, fd);             // <infotext>
   }
@@ -4457,7 +4456,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     putc(SN_MIDWORD, fd);                               // <sectionID>
     putc(SNF_REQUIRED, fd);                             // <sectionflags>
 
-    size_t i = STRLEN(spin->si_midword);
+    size_t i = strlen(spin->si_midword);
     put_bytes(fd, i, 4);                                // <sectionlen>
     fwv &= fwrite(spin->si_midword, i, 1, fd);
     // <midword>
@@ -4517,8 +4516,8 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     assert(gap->ga_len >= 0);
     for (size_t i = 0; i < (size_t)gap->ga_len; i++) {
       fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
-      l += 1 + STRLEN(ftp->ft_from);  // count <*fromlen> and <*from>
-      l += 1 + STRLEN(ftp->ft_to);    // count <*tolen> and <*to>
+      l += 1 + strlen((char *)ftp->ft_from);  // count <*fromlen> and <*from>
+      l += 1 + strlen((char *)ftp->ft_to);    // count <*tolen> and <*to>
     }
     if (round == 2) {
       l++;                            // count <salflags>
@@ -4545,8 +4544,8 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
       // <sal> : <salfromlen> <salfrom> <saltolen> <salto>
       fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
       for (unsigned int rr = 1; rr <= 2; rr++) {
-        char_u *p = rr == 1 ? ftp->ft_from : ftp->ft_to;
-        l = STRLEN(p);
+        char *p = rr == 1 ? (char *)ftp->ft_from : (char *)ftp->ft_to;
+        l = strlen(p);
         assert(l < INT_MAX);
         putc((int)l, fd);
         if (l > 0) {
@@ -4562,13 +4561,13 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     putc(SN_SOFO, fd);                                  // <sectionID>
     putc(0, fd);                                        // <sectionflags>
 
-    size_t l = STRLEN(spin->si_sofofr);
-    put_bytes(fd, l + STRLEN(spin->si_sofoto) + 4, 4);  // <sectionlen>
+    size_t l = strlen(spin->si_sofofr);
+    put_bytes(fd, l + strlen(spin->si_sofoto) + 4, 4);  // <sectionlen>
 
     put_bytes(fd, l, 2);                                // <sofofromlen>
     fwv &= fwrite(spin->si_sofofr, l, 1, fd);           // <sofofrom>
 
-    l = STRLEN(spin->si_sofoto);
+    l = strlen(spin->si_sofoto);
     put_bytes(fd, l, 2);                                // <sofotolen>
     fwv &= fwrite(spin->si_sofoto, l, 1, fd);           // <sofoto>
   }
@@ -4589,7 +4588,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
       todo = spin->si_commonwords.ht_used;
       for (hi = spin->si_commonwords.ht_array; todo > 0; hi++) {
         if (!HASHITEM_EMPTY(hi)) {
-          size_t l = STRLEN(hi->hi_key) + 1;
+          size_t l = strlen(hi->hi_key) + 1;
           len += l;
           if (round == 2) {                             // <word>
             fwv &= fwrite(hi->hi_key, l, 1, fd);
@@ -4655,7 +4654,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     putc(SN_COMPOUND, fd);                              // <sectionID>
     putc(0, fd);                                        // <sectionflags>
 
-    size_t l = STRLEN(spin->si_compflags);
+    size_t l = strlen(spin->si_compflags);
     assert(spin->si_comppat.ga_len >= 0);
     for (size_t i = 0; i < (size_t)spin->si_comppat.ga_len; i++) {
       l += strlen(((char **)(spin->si_comppat.ga_data))[i]) + 1;
@@ -4675,7 +4674,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
       fwv &= fwrite(p, strlen(p), 1, fd);               // <comppattext>
     }
     // <compflags>
-    fwv &= fwrite(spin->si_compflags, STRLEN(spin->si_compflags), 1, fd);
+    fwv &= fwrite(spin->si_compflags, strlen(spin->si_compflags), 1, fd);
   }
 
   // SN_NOBREAK: NOBREAK flag
@@ -4694,7 +4693,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     putc(SN_SYLLABLE, fd);                              // <sectionID>
     putc(0, fd);                                        // <sectionflags>
 
-    size_t l = STRLEN(spin->si_syllable);
+    size_t l = strlen(spin->si_syllable);
     put_bytes(fd, l, 4);                                // <sectionlen>
     fwv &= fwrite(spin->si_syllable, l, 1, fd);         // <syllable>
   }
@@ -4913,7 +4912,7 @@ void ex_mkspell(exarg_T *eap)
 // Writes the file with the name "wfname", with ".spl" changed to ".sug".
 static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
 {
-  char_u *fname = NULL;
+  char *fname = NULL;
   int len;
   slang_T *slang;
   bool free_slang = false;
@@ -4972,10 +4971,10 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
   // Make the file name by changing ".spl" to ".sug".
   fname = xmalloc(MAXPATHL);
   STRLCPY(fname, wfname, MAXPATHL);
-  len = (int)STRLEN(fname);
+  len = (int)strlen(fname);
   fname[len - 2] = 'u';
   fname[len - 1] = 'g';
-  sug_write(spin, fname);
+  sug_write(spin, (char_u *)fname);
 
 theend:
   xfree(fname);
@@ -5036,7 +5035,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
       if (c == 0) {
         // Sound-fold the word.
         tword[depth] = NUL;
-        spell_soundfold(slang, tword, true, tsalword);
+        spell_soundfold(slang, (char *)tword, true, (char *)tsalword);
 
         // We use the "flags" field for the MSB of the wordnr,
         // "region" for the LSB of the wordnr.
@@ -5250,8 +5249,8 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
 
   for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
     // <sugline>: <sugnr> ... NUL
-    char_u *line = (char_u *)ml_get_buf(spin->si_spellbuf, lnum, false);
-    size_t len = STRLEN(line) + 1;
+    char *line = ml_get_buf(spin->si_spellbuf, lnum, false);
+    size_t len = strlen(line) + 1;
     if (fwrite(line, len, 1, fd) == 0) {
       emsg(_(e_write));
       goto theend;
@@ -5316,7 +5315,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
   char *wfname = xmalloc(MAXPATHL);
 
   if (fcount >= 1) {
-    len = (int)STRLEN(fnames[0]);
+    len = (int)strlen(fnames[0]);
     if (fcount == 1 && len > 4 && strcmp(fnames[0] + len - 4, ".add") == 0) {
       // For ":mkspell path/en.latin1.add" output file is
       // "path/en.latin1.add.spl".
@@ -5689,7 +5688,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
 // Initialize 'spellfile' for the current buffer.
 static void init_spellfile(void)
 {
-  char_u *buf;
+  char *buf;
   int l;
   char_u *fname;
   char_u *rtp;
@@ -5720,29 +5719,29 @@ static void init_spellfile(void)
         STRLCPY(buf, curbuf->b_s.b_p_spl, lstart - (char_u *)curbuf->b_s.b_p_spl);
       } else {
         // Copy the path from 'runtimepath' to buf[].
-        copy_option_part((char **)&rtp, (char *)buf, MAXPATHL, ",");
+        copy_option_part((char **)&rtp, buf, MAXPATHL, ",");
       }
-      if (os_file_is_writable((char *)buf) == 2) {
+      if (os_file_is_writable(buf) == 2) {
         // Use the first language name from 'spelllang' and the
         // encoding used in the first loaded .spl file.
         if (aspath) {
           STRLCPY(buf, curbuf->b_s.b_p_spl, lend - (char_u *)curbuf->b_s.b_p_spl + 1);
         } else {
           // Create the "spell" directory if it doesn't exist yet.
-          l = (int)STRLEN(buf);
-          vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l, "/spell");
-          if (os_file_is_writable((char *)buf) != 2) {
-            os_mkdir((char *)buf, 0755);
+          l = (int)strlen(buf);
+          vim_snprintf(buf + l, MAXPATHL - (size_t)l, "/spell");
+          if (os_file_is_writable(buf) != 2) {
+            os_mkdir(buf, 0755);
           }
 
-          l = (int)STRLEN(buf);
-          vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l,
+          l = (int)strlen(buf);
+          vim_snprintf(buf + l, MAXPATHL - (size_t)l,
                        "/%.*s", (int)(lend - lstart), lstart);
         }
-        l = (int)STRLEN(buf);
+        l = (int)strlen(buf);
         fname = (char_u *)LANGP_ENTRY(curwin->w_s->b_langp, 0)
                 ->lp_slang->sl_fname;
-        vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l, ".%s.add",
+        vim_snprintf(buf + l, MAXPATHL - (size_t)l, ".%s.add",
                      ((fname != NULL
                        && strstr(path_tail((char *)fname), ".ascii.") != NULL)
                       ? "ascii"