Merge remote-tracking branch 'upstream/master' into colorcolcharcolorcolchar

1 files changed, 463 insertions, 609 deletions

diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 44414ca1a5..2607fddc31 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -1,6 +1,3 @@
-// This is an open source non-commercial project. Dear PVS-Studio, please check
-// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
-
 // spellfile.c: code for reading and writing spell files.
 //
 // See spell.c for information about spell checking.
@@ -231,44 +228,46 @@
 #include <inttypes.h>
 #include <limits.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
-#include "auto/config.h"
 #include "nvim/arglist.h"
-#include "nvim/ascii.h"
+#include "nvim/ascii_defs.h"
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
 #include "nvim/drawscreen.h"
 #include "nvim/ex_cmds_defs.h"
 #include "nvim/fileio.h"
+#include "nvim/func_attr.h"
 #include "nvim/garray.h"
 #include "nvim/gettext.h"
 #include "nvim/globals.h"
 #include "nvim/hashtab.h"
-#include "nvim/macros.h"
+#include "nvim/macros_defs.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/option.h"
+#include "nvim/option_vars.h"
+#include "nvim/os/fs.h"
 #include "nvim/os/input.h"
 #include "nvim/os/os.h"
 #include "nvim/os/time.h"
 #include "nvim/path.h"
-#include "nvim/pos.h"
+#include "nvim/pos_defs.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
 #include "nvim/spell.h"
 #include "nvim/spell_defs.h"
 #include "nvim/spellfile.h"
 #include "nvim/strings.h"
-#include "nvim/types.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
-#include "nvim/vim.h"
+#include "nvim/vim_defs.h"
 
 // Special byte values for <byte>.  Some are only used in the tree for
 // postponed prefixes, some only in the other trees.  This is a bit messy...
@@ -322,11 +321,15 @@ enum {
   CF_UPPER = 0x02,
 };
 
-static char *e_spell_trunc = N_("E758: Truncated spell file");
-static char *e_illegal_character_in_word = N_("E1280: Illegal character in word");
-static char *e_afftrailing = N_("Trailing text in %s line %d: %s");
-static char *e_affname = N_("Affix name too long in %s line %d: %s");
-static char *msg_compressing = N_("Compressing word tree...");
+static const char *e_spell_trunc = N_("E758: Truncated spell file");
+static const char e_error_while_reading_sug_file_str[]
+  = N_("E782: Error while reading .sug file: %s");
+static const char e_duplicate_char_in_map_entry[]
+  = N_("E783: Duplicate char in MAP entry");
+static const char *e_illegal_character_in_word = N_("E1280: Illegal character in word");
+static const char *e_afftrailing = N_("Trailing text in %s line %d: %s");
+static const char *e_affname = N_("Affix name too long in %s line %d: %s");
+static const char *msg_compressing = N_("Compressing word tree...");
 
 #define MAXLINELEN  500         // Maximum length in bytes of a line in a .aff
                                 // and .dic file.
@@ -386,7 +389,7 @@ typedef struct affheader_S {
 
 // Flag used in compound items.
 typedef struct compitem_S {
-  char_u ci_key[AH_KEY_LEN];    // key for hashtab == name of compound
+  char ci_key[AH_KEY_LEN];      // key for hashtab == name of compound
   unsigned ci_flag;             // affix name as number, uses "af_flagtype"
   int ci_newID;                 // affix ID after renumbering.
 } compitem_T;
@@ -404,14 +407,14 @@ typedef struct sblock_S sblock_T;
 struct sblock_S {
   int sb_used;                  // nr of bytes already in use
   sblock_T *sb_next;         // next block in list
-  char_u sb_data[1];            // data, actually longer
+  char sb_data[];            // data
 };
 
 // A node in the tree.
 typedef struct wordnode_S wordnode_T;
 struct wordnode_S {
   union {   // shared to save space
-    char_u hashkey[6];          // the hash key, only used while compressing
+    uint8_t hashkey[6];         // the hash key, only used while compressing
     int index;                  // index in written nodes (valid after first
                                 // round)
   } wn_u1;
@@ -422,17 +425,17 @@ struct wordnode_S {
   wordnode_T *wn_child;        // child (next byte in word)
   wordnode_T *wn_sibling;      // next sibling (alternate byte in word,
                                //   always sorted)
-  int wn_refs;                  // Nr. of references to this node.  Only
-                                //   relevant for first node in a list of
-                                //   siblings, in following siblings it is
-                                //   always one.
-  char_u wn_byte;               // Byte for this node. NUL for word end
+  int wn_refs;                 // Nr. of references to this node.  Only
+                               //   relevant for first node in a list of
+                               //   siblings, in following siblings it is
+                               //   always one.
+  uint8_t wn_byte;             // Byte for this node. NUL for word end
 
   // Info for when "wn_byte" is NUL.
   // In PREFIXTREE "wn_region" is used for the prefcondnr.
   // In the soundfolded word tree "wn_flags" has the MSW of the wordnr and
   // "wn_region" the LSW of the wordnr.
-  char_u wn_affixID;            // supported/required prefix ID or 0
+  uint8_t wn_affixID;           // supported/required prefix ID or 0
   uint16_t wn_flags;            // WF_ flags
   int16_t wn_region;            // region mask
 
@@ -448,24 +451,24 @@ struct wordnode_S {
 // Info used while reading the spell files.
 typedef struct spellinfo_S {
   wordnode_T *si_foldroot;     // tree with case-folded words
-  long si_foldwcount;           // nr of words in si_foldroot
+  int si_foldwcount;           // nr of words in si_foldroot
 
   wordnode_T *si_keeproot;     // tree with keep-case words
-  long si_keepwcount;           // nr of words in si_keeproot
+  int si_keepwcount;           // nr of words in si_keeproot
 
   wordnode_T *si_prefroot;     // tree with postponed prefixes
 
-  long si_sugtree;              // creating the soundfolding trie
+  int si_sugtree;              // creating the soundfolding trie
 
   sblock_T *si_blocks;       // memory blocks used
-  long si_blocks_cnt;           // memory blocks allocated
+  int si_blocks_cnt;           // memory blocks allocated
   int si_did_emsg;              // true when ran out of memory
 
-  long si_compress_cnt;         // words to add before lowering
-                                // compression limit
+  int si_compress_cnt;         // words to add before lowering
+                               // compression limit
   wordnode_T *si_first_free;   // List of nodes that have been freed during
                                // compression, linked by "wn_child" field.
-  long si_free_count;           // number of nodes in si_first_free
+  int si_free_count;           // number of nodes in si_first_free
 #ifdef SPELL_PRINTTREE
   int si_wordnode_nr;           // sequence nr for nodes
 #endif
@@ -482,7 +485,7 @@ typedef struct spellinfo_S {
   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];
+  char si_region_name[MAXREGIONS * 2 + 1];
   // region names; used only if
   // si_region_count > 1)
 
@@ -508,7 +511,7 @@ typedef struct spellinfo_S {
   garray_T si_comppat;          // CHECKCOMPOUNDPATTERN items, each stored as
                                 // a string
   char *si_compflags;           // flags used for compounding
-  char_u si_nobreak;            // NOBREAK
+  char si_nobreak;              // NOBREAK
   char *si_syllable;            // syllable string
   garray_T si_prefcond;         // table with conditions for postponed
                                 // prefixes, each stored as a string
@@ -593,29 +596,25 @@ static inline int spell_check_magic_string(FILE *const fd)
 /// @return  the slang_T the spell file was loaded into.  NULL for error.
 slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
 {
-  FILE *fd;
   char *p;
-  int n;
-  int len;
   slang_T *lp = NULL;
-  int c = 0;
   int res;
   bool did_estack_push = false;
 
-  fd = os_fopen(fname, "r");
+  FILE *fd = os_fopen(fname, "r");
   if (fd == NULL) {
     if (!silent) {
       semsg(_(e_notopen), fname);
     } else if (p_verbose > 2) {
       verbose_enter();
-      smsg((char *)e_notopen, fname);
+      smsg(0, e_notopen, fname);
       verbose_leave();
     }
     goto endFAIL;
   }
   if (p_verbose > 2) {
     verbose_enter();
-    smsg(_("Reading spell file \"%s\""), fname);
+    smsg(0, _("Reading spell file \"%s\""), fname);
     verbose_leave();
   }
 
@@ -649,7 +648,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
   case 0:
     break;
   }
-  c = getc(fd);                                         // <versionnr>
+  int c = getc(fd);                                         // <versionnr>
   if (c < VIMSPELLVERSION) {
     emsg(_("E771: Old spell file, needs to be updated"));
     goto endFAIL;
@@ -660,13 +659,13 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
 
   // <SECTIONS>: <section> ... <sectionend>
   // <section>: <sectionID> <sectionflags> <sectionlen> (section contents)
-  for (;;) {
-    n = getc(fd);                           // <sectionID> or <sectionend>
+  while (true) {
+    int n = getc(fd);                           // <sectionID> or <sectionend>
     if (n == SN_END) {
       break;
     }
     c = getc(fd);                                       // <sectionflags>
-    len = get4c(fd);                                    // <sectionlen>
+    int len = get4c(fd);                                    // <sectionlen>
     if (len < 0) {
       goto truncerr;
     }
@@ -674,7 +673,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
     res = 0;
     switch (n) {
     case SN_INFO:
-      lp->sl_info = READ_STRING(fd, len);               // <infotext>
+      lp->sl_info = read_string(fd, (size_t)len);  // <infotext>
       if (lp->sl_info == NULL) {
         goto endFAIL;
       }
@@ -689,7 +688,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
       break;
 
     case SN_MIDWORD:
-      lp->sl_midword = READ_STRING(fd, len);            // <midword>
+      lp->sl_midword = read_string(fd, (size_t)len);  // <midword>
       if (lp->sl_midword == NULL) {
         goto endFAIL;
       }
@@ -716,7 +715,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
       break;
 
     case SN_MAP:
-      p = (char *)READ_STRING(fd, len);                         // <mapstr>
+      p = read_string(fd, (size_t)len);  // <mapstr>
       if (p == NULL) {
         goto endFAIL;
       }
@@ -749,7 +748,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
       break;
 
     case SN_SYLLABLE:
-      lp->sl_syllable = READ_STRING(fd, len);           // <syllable>
+      lp->sl_syllable = read_string(fd, (size_t)len);  // <syllable>
       if (lp->sl_syllable == NULL) {
         goto endFAIL;
       }
@@ -838,19 +837,16 @@ endOK:
 
 // Fill in the wordcount fields for a trie.
 // Returns the total number of words.
-static void tree_count_words(const char_u *byts, idx_T *idxs)
+static void tree_count_words(const uint8_t *byts, idx_T *idxs)
 {
-  int depth;
   idx_T arridx[MAXWLEN];
   int curi[MAXWLEN];
-  int c;
-  idx_T n;
   int wordcount[MAXWLEN];
 
   arridx[0] = 0;
   curi[0] = 1;
   wordcount[0] = 0;
-  depth = 0;
+  int depth = 0;
   while (depth >= 0 && !got_int) {
     if (curi[depth] > byts[arridx[depth]]) {
       // Done all bytes at this node, go up one level.
@@ -863,10 +859,10 @@ static void tree_count_words(const char_u *byts, idx_T *idxs)
       fast_breakcheck();
     } else {
       // Do one more byte at this node.
-      n = arridx[depth] + curi[depth];
+      idx_T n = arridx[depth] + curi[depth];
       curi[depth]++;
 
-      c = byts[n];
+      int c = byts[n];
       if (c == 0) {
         // End of word, count it.
         wordcount[depth]++;
@@ -891,40 +887,31 @@ static void tree_count_words(const char_u *byts, idx_T *idxs)
 /// Load the .sug files for languages that have one and weren't loaded yet.
 void suggest_load_files(void)
 {
-  langp_T *lp;
-  slang_T *slang;
-  char *dotp;
-  FILE *fd;
   char buf[MAXWLEN];
-  int i;
-  time_t timestamp;
-  int wcount;
-  int wordnr;
   garray_T ga;
-  int c;
 
   // Do this for all languages that support sound folding.
   for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
-    lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
-    slang = lp->lp_slang;
+    langp_T *lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
+    slang_T *slang = lp->lp_slang;
     if (slang->sl_sugtime != 0 && !slang->sl_sugloaded) {
       // Change ".spl" to ".sug" and open the file.  When the file isn't
       // found silently skip it.  Do set "sl_sugloaded" so that we
       // don't try again and again.
       slang->sl_sugloaded = true;
 
-      dotp = strrchr(slang->sl_fname, '.');
+      char *dotp = strrchr(slang->sl_fname, '.');
       if (dotp == NULL || path_fnamecmp(dotp, ".spl") != 0) {
         continue;
       }
       STRCPY(dotp, ".sug");
-      fd = os_fopen(slang->sl_fname, "r");
+      FILE *fd = os_fopen(slang->sl_fname, "r");
       if (fd == NULL) {
         goto nextone;
       }
 
       // <SUGHEADER>: <fileID> <versionnr> <timestamp>
-      for (i = 0; i < VIMSUGMAGICL; i++) {
+      for (int i = 0; i < VIMSUGMAGICL; i++) {
         buf[i] = (char)getc(fd);                              // <fileID>
       }
       if (strncmp(buf, VIMSUGMAGIC, VIMSUGMAGICL) != 0) {
@@ -932,7 +919,7 @@ void suggest_load_files(void)
               slang->sl_fname);
         goto nextone;
       }
-      c = getc(fd);                                     // <versionnr>
+      int c = getc(fd);                                     // <versionnr>
       if (c < VIMSUGVERSION) {
         semsg(_("E779: Old .sug file, needs to be updated: %s"),
               slang->sl_fname);
@@ -945,7 +932,7 @@ void suggest_load_files(void)
 
       // Check the timestamp, it must be exactly the same as the one in
       // the .spl file.  Otherwise the word numbers won't match.
-      timestamp = get8ctime(fd);                        // <timestamp>
+      time_t timestamp = get8ctime(fd);                        // <timestamp>
       if (timestamp != slang->sl_sugtime) {
         semsg(_("E781: .sug file doesn't match .spl file: %s"),
               slang->sl_fname);
@@ -957,7 +944,7 @@ void suggest_load_files(void)
       if (spell_read_tree(fd, &slang->sl_sbyts, NULL, &slang->sl_sidxs,
                           false, 0) != 0) {
 someerror:
-        semsg(_("E782: error while reading .sug file: %s"),
+        semsg(_(e_error_while_reading_sug_file_str),
               slang->sl_fname);
         slang_clear_sug(slang);
         goto nextone;
@@ -971,7 +958,7 @@ someerror:
       slang->sl_sugbuf = open_spellbuf();
 
       // <sugwcount>
-      wcount = get4c(fd);
+      int wcount = get4c(fd);
       if (wcount < 0) {
         goto someerror;
       }
@@ -979,14 +966,14 @@ someerror:
       // Read all the wordnr lists into the buffer, one NUL terminated
       // list per line.
       ga_init(&ga, 1, 100);
-      for (wordnr = 0; wordnr < wcount; wordnr++) {
+      for (int wordnr = 0; wordnr < wcount; wordnr++) {
         ga.ga_len = 0;
-        for (;;) {
+        while (true) {
           c = getc(fd);                                     // <sugline>
           if (c < 0) {
             goto someerror;
           }
-          GA_APPEND(char_u, &ga, (char_u)c);
+          GA_APPEND(uint8_t, &ga, (uint8_t)c);
           if (c == NUL) {
             break;
           }
@@ -1000,8 +987,8 @@ someerror:
 
       // Need to put word counts in the word tries, so that we can find
       // a word by its number.
-      tree_count_words((char_u *)slang->sl_fbyts, slang->sl_fidxs);
-      tree_count_words((char_u *)slang->sl_sbyts, slang->sl_sidxs);
+      tree_count_words(slang->sl_fbyts, slang->sl_fidxs);
+      tree_count_words(slang->sl_sbyts, slang->sl_sidxs);
 
 nextone:
       if (fd != NULL) {
@@ -1017,10 +1004,9 @@ nextone:
 // Returns NULL when the count is zero.
 // Sets "*cntp" to SP_*ERROR when there is an error, length of the result
 // otherwise.
-static char_u *read_cnt_string(FILE *fd, int cnt_bytes, int *cntp)
+static char *read_cnt_string(FILE *fd, int cnt_bytes, int *cntp)
 {
   int cnt = 0;
-  char_u *str;
 
   // read the length bytes, MSB first
   for (int i = 0; i < cnt_bytes; i++) {
@@ -1036,7 +1022,7 @@ static char_u *read_cnt_string(FILE *fd, int cnt_bytes, int *cntp)
   if (cnt == 0) {
     return NULL;            // nothing to read, return NULL
   }
-  str = READ_STRING(fd, cnt);
+  char *str = read_string(fd, (size_t)cnt);
   if (str == NULL) {
     *cntp = SP_OTHERERROR;
   }
@@ -1060,18 +1046,16 @@ static int read_region_section(FILE *fd, slang_T *lp, int len)
 // Return SP_*ERROR flags.
 static int read_charflags_section(FILE *fd)
 {
-  char *flags;
-  char_u *fol;
   int flagslen, follen;
 
   // <charflagslen> <charflags>
-  flags = (char *)read_cnt_string(fd, 1, &flagslen);
+  char *flags = read_cnt_string(fd, 1, &flagslen);
   if (flagslen < 0) {
     return flagslen;
   }
 
   // <folcharslen> <folchars>
-  fol = read_cnt_string(fd, 2, &follen);
+  char *fol = read_cnt_string(fd, 2, &follen);
   if (follen < 0) {
     xfree(flags);
     return follen;
@@ -1079,7 +1063,7 @@ static int read_charflags_section(FILE *fd)
 
   // Set the word-char flags and fill SPELL_ISUPPER() table.
   if (flags != NULL && fol != NULL) {
-    set_spell_charflags((char_u *)flags, flagslen, (char *)fol);
+    set_spell_charflags(flags, flagslen, fol);
   }
 
   xfree(flags);
@@ -1129,10 +1113,9 @@ static int read_prefcond_section(FILE *fd, slang_T *lp)
 // Return SP_*ERROR flags.
 static int read_rep_section(FILE *fd, garray_T *gap, int16_t *first)
 {
-  int cnt;
   fromto_T *ftp;
 
-  cnt = get2c(fd);                                      // <repcount>
+  int cnt = get2c(fd);                                      // <repcount>
   if (cnt < 0) {
     return SP_TRUNCERROR;
   }
@@ -1143,14 +1126,14 @@ static int read_rep_section(FILE *fd, garray_T *gap, int16_t *first)
   for (; gap->ga_len < cnt; gap->ga_len++) {
     int c;
     ftp = &((fromto_T *)gap->ga_data)[gap->ga_len];
-    ftp->ft_from = (char *)read_cnt_string(fd, 1, &c);
+    ftp->ft_from = read_cnt_string(fd, 1, &c);
     if (c < 0) {
       return c;
     }
     if (c == 0) {
       return SP_FORMERROR;
     }
-    ftp->ft_to = (char *)read_cnt_string(fd, 1, &c);
+    ftp->ft_to = read_cnt_string(fd, 1, &c);
     if (c <= 0) {
       xfree(ftp->ft_from);
       if (c < 0) {
@@ -1177,12 +1160,6 @@ static int read_rep_section(FILE *fd, garray_T *gap, int16_t *first)
 // Return SP_*ERROR flags.
 static int read_sal_section(FILE *fd, slang_T *slang)
 {
-  int cnt;
-  garray_T *gap;
-  salitem_T *smp;
-  int ccnt;
-  char_u *p;
-
   slang->sl_sofo = false;
 
   const int flags = getc(fd);                   // <salflags>
@@ -1196,12 +1173,12 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     slang->sl_rem_accents = true;
   }
 
-  cnt = get2c(fd);                              // <salcount>
+  int cnt = get2c(fd);                              // <salcount>
   if (cnt < 0) {
     return SP_TRUNCERROR;
   }
 
-  gap = &slang->sl_sal;
+  garray_T *gap = &slang->sl_sal;
   ga_init(gap, sizeof(salitem_T), 10);
   ga_grow(gap, cnt + 1);
 
@@ -1209,13 +1186,13 @@ static int read_sal_section(FILE *fd, slang_T *slang)
   for (; gap->ga_len < cnt; gap->ga_len++) {
     int c = NUL;
 
-    smp = &((salitem_T *)gap->ga_data)[gap->ga_len];
-    ccnt = getc(fd);                            // <salfromlen>
+    salitem_T *smp = &((salitem_T *)gap->ga_data)[gap->ga_len];
+    int ccnt = getc(fd);                            // <salfromlen>
     if (ccnt < 0) {
       return SP_TRUNCERROR;
     }
-    p = xmalloc((size_t)ccnt + 2);
-    smp->sm_lead = (char *)p;
+    char *p = xmalloc((size_t)ccnt + 2);
+    smp->sm_lead = p;
 
     // Read up to the first special char into sm_lead.
     int i = 0;
@@ -1224,9 +1201,9 @@ static int read_sal_section(FILE *fd, slang_T *slang)
       if (vim_strchr("0123456789(-<^$", c) != NULL) {
         break;
       }
-      *p++ = (char_u)c;
+      *p++ = (char)(uint8_t)c;
     }
-    smp->sm_leadlen = (int)(p - (char_u *)smp->sm_lead);
+    smp->sm_leadlen = (int)(p - smp->sm_lead);
     *p++ = NUL;
 
     // Put (abc) chars in sm_oneof, if any.
@@ -1237,7 +1214,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
         if (c == ')') {
           break;
         }
-        *p++ = (char_u)c;
+        *p++ = (char)(uint8_t)c;
       }
       *p++ = NUL;
       if (++i < ccnt) {
@@ -1248,22 +1225,22 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     }
 
     // Any following chars go in sm_rules.
-    smp->sm_rules = (char *)p;
+    smp->sm_rules = p;
     if (i < ccnt) {
       // store the char we got while checking for end of sm_lead
-      *p++ = (char_u)c;
+      *p++ = (char)(uint8_t)c;
     }
     i++;
     if (i < ccnt) {
       SPELL_READ_NONNUL_BYTES(                  // <salfrom>
-                                                (char *)p, (size_t)(ccnt - i), fd,
+                                                p, (size_t)(ccnt - i), fd,
                                                 xfree(smp->sm_lead));
       p += (ccnt - i);
     }
     *p++ = NUL;
 
     // <saltolen> <salto>
-    smp->sm_to = (char *)read_cnt_string(fd, 1, &ccnt);
+    smp->sm_to = read_cnt_string(fd, 1, &ccnt);
     if (ccnt < 0) {
       xfree(smp->sm_lead);
       return ccnt;
@@ -1275,7 +1252,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     if (smp->sm_oneof == NULL) {
       smp->sm_oneof_w = NULL;
     } else {
-      smp->sm_oneof_w = mb_str2wide((char *)smp->sm_oneof);
+      smp->sm_oneof_w = mb_str2wide(smp->sm_oneof);
     }
     if (smp->sm_to == NULL) {
       smp->sm_to_w = NULL;
@@ -1287,15 +1264,15 @@ static int read_sal_section(FILE *fd, slang_T *slang)
   if (!GA_EMPTY(gap)) {
     // Add one extra entry to mark the end with an empty sm_lead.  Avoids
     // that we need to check the index every time.
-    smp = &((salitem_T *)gap->ga_data)[gap->ga_len];
-    p = xmalloc(1);
+    salitem_T *smp = &((salitem_T *)gap->ga_data)[gap->ga_len];
+    char *p = xmalloc(1);
     p[0] = NUL;
-    smp->sm_lead = (char *)p;
+    smp->sm_lead = p;
     smp->sm_lead_w = mb_str2wide(smp->sm_lead);
     smp->sm_leadlen = 0;
     smp->sm_oneof = NULL;
     smp->sm_oneof_w = NULL;
-    smp->sm_rules = (char *)p;
+    smp->sm_rules = p;
     smp->sm_to = NULL;
     smp->sm_to_w = NULL;
     gap->ga_len++;
@@ -1313,17 +1290,16 @@ static int read_words_section(FILE *fd, slang_T *lp, int len)
 {
   int done = 0;
   int i;
-  int c;
-  char_u word[MAXWLEN];
+  uint8_t word[MAXWLEN];
 
   while (done < len) {
     // Read one word at a time.
     for (i = 0;; i++) {
-      c = getc(fd);
+      int c = getc(fd);
       if (c == EOF) {
         return SP_TRUNCERROR;
       }
-      word[i] = (char_u)c;
+      word[i] = (uint8_t)c;
       if (word[i] == NUL) {
         break;
       }
@@ -1344,19 +1320,18 @@ static int read_words_section(FILE *fd, slang_T *lp, int len)
 static int read_sofo_section(FILE *fd, slang_T *slang)
 {
   int cnt;
-  char *from, *to;
   int res;
 
   slang->sl_sofo = true;
 
   // <sofofromlen> <sofofrom>
-  from = (char *)read_cnt_string(fd, 2, &cnt);
+  char *from = read_cnt_string(fd, 2, &cnt);
   if (cnt < 0) {
     return cnt;
   }
 
   // <sofotolen> <sofoto>
-  to = (char *)read_cnt_string(fd, 2, &cnt);
+  char *to = read_cnt_string(fd, 2, &cnt);
   if (cnt < 0) {
     xfree(from);
     return cnt;
@@ -1382,16 +1357,13 @@ static int read_sofo_section(FILE *fd, slang_T *slang)
 static int read_compound(FILE *fd, slang_T *slang, int len)
 {
   int todo = len;
-  int c;
-  int atstart;
   int cnt;
-  garray_T *gap;
 
   if (todo < 2) {
     return SP_FORMERROR;        // need at least two bytes
   }
   todo--;
-  c = getc(fd);                                         // <compmax>
+  int c = getc(fd);                                         // <compmax>
   if (c < 2) {
     c = MAXWLEN;
   }
@@ -1420,7 +1392,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
     todo--;
     slang->sl_compoptions = c;
 
-    gap = &slang->sl_comppat;
+    garray_T *gap = &slang->sl_comppat;
     c = get2c(fd);                                      // <comppatcount>
     if (c < 0) {
       return SP_TRUNCERROR;
@@ -1429,7 +1401,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
     ga_init(gap, sizeof(char *), c);
     ga_grow(gap, c);
     while (--c >= 0) {
-      ((char **)(gap->ga_data))[gap->ga_len++] = (char *)read_cnt_string(fd, 1, &cnt);
+      ((char **)(gap->ga_data))[gap->ga_len++] = read_cnt_string(fd, 1, &cnt);
       // <comppatlen> <comppattext>
       if (cnt < 0) {
         return cnt;
@@ -1465,12 +1437,12 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
   uint8_t *crp = xmalloc((size_t)todo + 1);
   slang->sl_comprules = crp;
 
-  char_u *pp = (char_u *)pat;
+  char *pp = pat;
   *pp++ = '^';
   *pp++ = '\\';
   *pp++ = '(';
 
-  atstart = 1;
+  int atstart = 1;
   while (todo-- > 0) {
     c = getc(fd);                                       // <compflags>
     if (c == EOF) {
@@ -1481,7 +1453,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
     // Add all flags to "sl_compallflags".
     if (vim_strchr("?*+[]/", c) == NULL
         && !byte_in_str(slang->sl_compallflags, c)) {
-      *ap++ = (char_u)c;
+      *ap++ = (uint8_t)c;
       *ap = NUL;
     }
 
@@ -1494,7 +1466,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
         atstart = 0;
       } else {
         if (!byte_in_str(slang->sl_compstartflags, c)) {
-          *cp++ = (char_u)c;
+          *cp++ = (uint8_t)c;
           *cp = NUL;
         }
         if (atstart == 1) {
@@ -1509,7 +1481,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
         XFREE_CLEAR(slang->sl_comprules);
         crp = NULL;
       } else {
-        *crp++ = (char_u)c;
+        *crp++ = (uint8_t)c;
       }
     }
 
@@ -1521,7 +1493,7 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
       if (c == '?' || c == '+' || c == '~') {
         *pp++ = '\\';               // "a?" becomes "a\?", "a+" becomes "a\+"
       }
-      pp += utf_char2bytes(c, (char *)pp);
+      pp += utf_char2bytes(c, pp);
     }
   }
 
@@ -1545,10 +1517,10 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
 
 // Set the SOFOFROM and SOFOTO items in language "lp".
 // Returns SP_*ERROR flags when there is something wrong.
-static int set_sofo(slang_T *lp, char *from, char *to)
+static int set_sofo(slang_T *lp, const char *from, const char *to)
 {
-  char *s;
-  char *p;
+  const char *s;
+  const char *p;
 
   // Use "sl_sal" as an array with 256 pointers to a list of wide
   // characters.  The index is the low byte of the character.
@@ -1563,7 +1535,7 @@ static int set_sofo(slang_T *lp, char *from, char *to)
   // First count the number of items for each list.  Temporarily use
   // sl_sal_first[] for this.
   for (p = from, s = to; *p != NUL && *s != NUL;) {
-    const int c = mb_cptr2char_adv((const char **)&p);
+    const int c = mb_cptr2char_adv(&p);
     MB_CPTR_ADV(s);
     if (c >= 256) {
       lp->sl_sal_first[c & 0xff]++;
@@ -1586,8 +1558,8 @@ static int set_sofo(slang_T *lp, char *from, char *to)
   // list.
   memset(lp->sl_sal_first, 0, sizeof(salfirst_T) * 256);
   for (p = from, s = to; *p != NUL && *s != NUL;) {
-    const int c = mb_cptr2char_adv((const char **)&p);
-    const int i = mb_cptr2char_adv((const char **)&s);
+    const int c = mb_cptr2char_adv(&p);
+    const int i = mb_cptr2char_adv(&s);
     if (c >= 256) {
       // Append the from-to chars at the end of the list with
       // the low byte.
@@ -1610,21 +1582,18 @@ static int set_sofo(slang_T *lp, char *from, char *to)
 // Fill the first-index table for "lp".
 static void set_sal_first(slang_T *lp)
 {
-  salfirst_T *sfirst;
-  salitem_T *smp;
-  int c;
   garray_T *gap = &lp->sl_sal;
 
-  sfirst = lp->sl_sal_first;
+  salfirst_T *sfirst = lp->sl_sal_first;
   for (int i = 0; i < 256; i++) {
     sfirst[i] = -1;
   }
-  smp = (salitem_T *)gap->ga_data;
+  salitem_T *smp = (salitem_T *)gap->ga_data;
   for (int i = 0; i < gap->ga_len; i++) {
     // Use the lowest byte of the first character.  For latin1 it's
     // the character, for other encodings it should differ for most
     // characters.
-    c = *smp[i].sm_lead_w & 0xff;
+    int c = *smp[i].sm_lead_w & 0xff;
     if (sfirst[c] == -1) {
       sfirst[c] = i;
 
@@ -1656,13 +1625,13 @@ static void set_sal_first(slang_T *lp)
 
 // Turn a multi-byte string into a wide character string.
 // Return it in allocated memory.
-static int *mb_str2wide(char *s)
+static int *mb_str2wide(const char *s)
 {
   int i = 0;
 
   int *res = xmalloc(((size_t)mb_charlen(s) + 1) * sizeof(int));
-  for (char *p = s; *p != NUL;) {
-    res[i++] = mb_ptr2char_adv((const char **)&p);
+  for (const char *p = s; *p != NUL;) {
+    res[i++] = mb_ptr2char_adv(&p);
   }
   res[i] = NUL;
 
@@ -1677,21 +1646,17 @@ static int *mb_str2wide(char *s)
 /// @param prefixcnt  when "prefixtree" is true: prefix count
 ///
 /// @return  zero when OK, SP_ value for an error.
-static int spell_read_tree(FILE *fd, char **bytsp, long *bytsp_len, idx_T **idxsp, bool prefixtree,
-                           int prefixcnt)
+static int spell_read_tree(FILE *fd, uint8_t **bytsp, int *bytsp_len, idx_T **idxsp,
+                           bool prefixtree, int prefixcnt)
   FUNC_ATTR_NONNULL_ARG(1, 2, 4)
 {
-  int idx;
-  char *bp;
-  idx_T *ip;
-
   // The tree size was computed when writing the file, so that we can
   // allocate it as one long block. <nodecount>
-  long len = get4c(fd);
+  int len = get4c(fd);
   if (len < 0) {
     return SP_TRUNCERROR;
   }
-  if ((size_t)len >= SIZE_MAX / sizeof(int)) {  // -V547
+  if ((size_t)len >= SIZE_MAX / sizeof(int)) {
     // Invalid length, multiply with sizeof(int) would overflow.
     return SP_FORMERROR;
   }
@@ -1700,18 +1665,18 @@ static int spell_read_tree(FILE *fd, char **bytsp, long *bytsp_len, idx_T **idxs
   }
 
   // Allocate the byte array.
-  bp = xmalloc((size_t)len);
+  uint8_t *bp = xmalloc((size_t)len);
   *bytsp = bp;
   if (bytsp_len != NULL) {
     *bytsp_len = len;
   }
 
   // Allocate the index array.
-  ip = xcalloc((size_t)len, sizeof(*ip));
+  idx_T *ip = xcalloc((size_t)len, sizeof(*ip));
   *idxsp = ip;
 
   // Recursively read the tree and store it in the array.
-  idx = read_tree_node(fd, (char_u *)bp, ip, (int)len, 0, prefixtree, prefixcnt);
+  int idx = read_tree_node(fd, bp, ip, len, 0, prefixtree, prefixcnt);
   if (idx < 0) {
     return idx;
   }
@@ -1731,18 +1696,13 @@ static int spell_read_tree(FILE *fd, char **bytsp, long *bytsp_len, idx_T **idxs
 /// @param startidx  current index in "byts" and "idxs"
 /// @param prefixtree  true for reading PREFIXTREE
 /// @param maxprefcondnr  maximum for <prefcondnr>
-static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx_T startidx,
+static idx_T read_tree_node(FILE *fd, uint8_t *byts, idx_T *idxs, int maxidx, idx_T startidx,
                             bool prefixtree, int maxprefcondnr)
 {
-  int len;
-  int i;
-  int n;
   idx_T idx = startidx;
-  int c;
-  int c2;
 #define SHARED_MASK     0x8000000
 
-  len = getc(fd);                                       // <siblingcount>
+  int len = getc(fd);                                       // <siblingcount>
   if (len <= 0) {
     return SP_TRUNCERROR;
   }
@@ -1750,11 +1710,11 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
   if (startidx + len >= maxidx) {
     return SP_FORMERROR;
   }
-  byts[idx++] = (char_u)len;
+  byts[idx++] = (uint8_t)len;
 
   // Read the byte values, flag/region bytes and shared indexes.
-  for (i = 1; i <= len; i++) {
-    c = getc(fd);                                       // <byte>
+  for (int i = 1; i <= len; i++) {
+    int c = getc(fd);                                       // <byte>
     if (c < 0) {
       return SP_TRUNCERROR;
     }
@@ -1776,7 +1736,7 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
 
           c |= getc(fd);                                // <affixID>
 
-          n = get2c(fd);                                // <prefcondnr>
+          int n = get2c(fd);                                // <prefcondnr>
           if (n >= maxprefcondnr) {
             return SP_FORMERROR;
           }
@@ -1785,7 +1745,7 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
                     // Read flags and optional region and prefix ID.  In
                     // idxs[] the flags go in the low two bytes, region above
                     // that and prefix ID above the region.
-          c2 = c;
+          int c2 = c;
           c = getc(fd);                                 // <flags>
           if (c2 == BY_FLAGS2) {
             c = (getc(fd) << 8) + c;                    // <flags2>
@@ -1802,7 +1762,7 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
         c = 0;
       } else {  // c == BY_INDEX
         // <nodeidx>
-        n = get3c(fd);
+        int n = get3c(fd);
         if (n < 0 || n >= maxidx) {
           return SP_FORMERROR;
         }
@@ -1810,20 +1770,19 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
         c = getc(fd);                                   // <xbyte>
       }
     }
-    byts[idx++] = (char_u)c;
+    byts[idx++] = (uint8_t)c;
   }
 
   // Recursively read the children for non-shared siblings.
   // Skip the end-of-word ones (zero byte value) and the shared ones (and
   // remove SHARED_MASK)
-  for (i = 1; i <= len; i++) {
+  for (int i = 1; i <= len; i++) {
     if (byts[startidx + i] != 0) {
       if (idxs[startidx + i] & SHARED_MASK) {
         idxs[startidx + i] &= ~SHARED_MASK;
       } else {
         idxs[startidx + i] = idx;
-        idx = read_tree_node(fd, byts, idxs, maxidx, idx,
-                             prefixtree, maxprefcondnr);
+        idx = read_tree_node(fd, byts, idxs, maxidx, idx, prefixtree, maxprefcondnr);
         if (idx < 0) {
           break;
         }
@@ -1839,10 +1798,9 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
 /// @param added_word  invoked through "zg"
 static void spell_reload_one(char *fname, bool added_word)
 {
-  slang_T *slang;
   bool didit = false;
 
-  for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
+  for (slang_T *slang = first_lang; slang != NULL; slang = slang->sl_next) {
     if (path_full_compare(fname, slang->sl_fname, false, true) == kEqualFiles) {
       slang_clear(slang);
       if (spell_load_file(fname, NULL, slang, false) == NULL) {
@@ -1857,7 +1815,7 @@ static void spell_reload_one(char *fname, bool added_word)
   // When "zg" was used and the file wasn't loaded yet, should redo
   // 'spelllang' to load it now.
   if (added_word && !didit) {
-    did_set_spelllang(curwin);
+    parse_spelllang(curwin);
   }
 }
 
@@ -1876,24 +1834,21 @@ static void spell_reload_one(char *fname, bool added_word)
 
 // Tunable parameters for when the tree is compressed.  Filled from the
 // 'mkspellmem' option.
-static long compress_start = 30000;     // memory / SBLOCKSIZE
-static long compress_inc = 100;         // memory / SBLOCKSIZE
-static long compress_added = 500000;    // word count
+static int compress_start = 30000;     // memory / SBLOCKSIZE
+static int compress_inc = 100;         // memory / SBLOCKSIZE
+static int compress_added = 500000;    // word count
 
 // Check the 'mkspellmem' option.  Return FAIL if it's wrong.
 // Sets "sps_flags".
 int spell_check_msm(void)
 {
   char *p = p_msm;
-  long start = 0;
-  long incr = 0;
-  long added = 0;
 
   if (!ascii_isdigit(*p)) {
     return FAIL;
   }
   // block count = (value * 1024) / SBLOCKSIZE (but avoid overflow)
-  start = (getdigits_long(&p, true, 0) * 10) / (SBLOCKSIZE / 102);
+  int start = (getdigits_int(&p, true, 0) * 10) / (SBLOCKSIZE / 102);
   if (*p != ',') {
     return FAIL;
   }
@@ -1901,7 +1856,7 @@ int spell_check_msm(void)
   if (!ascii_isdigit(*p)) {
     return FAIL;
   }
-  incr = (getdigits_long(&p, true, 0) * 102) / (SBLOCKSIZE / 10);
+  int incr = (getdigits_int(&p, true, 0) * 102) / (SBLOCKSIZE / 10);
   if (*p != ',') {
     return FAIL;
   }
@@ -1909,7 +1864,7 @@ int spell_check_msm(void)
   if (!ascii_isdigit(*p)) {
     return FAIL;
   }
-  added = getdigits_long(&p, true, 0) * 1024;
+  int added = getdigits_int(&p, true, 0) * 1024;
   if (*p != NUL) {
     return FAIL;
   }
@@ -1957,9 +1912,9 @@ static void spell_print_node(wordnode_T *node, int depth)
     PRINTSOME(line1, depth, "(%d)", node->wn_nr, 0);
     PRINTSOME(line2, depth, "    ", 0, 0);
     PRINTSOME(line3, depth, "    ", 0, 0);
-    msg((char_u *)line1);
-    msg((char_u *)line2);
-    msg((char_u *)line3);
+    msg(line1, 0);
+    msg(line2, 0);
+    msg(line3, 0);
   } else {
     node->wn_u1.index = true;
 
@@ -1983,9 +1938,9 @@ static void spell_print_node(wordnode_T *node, int depth)
     }
 
     if (node->wn_byte == NUL) {
-      msg((char_u *)line1);
-      msg((char_u *)line2);
-      msg((char_u *)line3);
+      msg(line1, 0);
+      msg(line2, 0);
+      msg(line3, 0);
     }
 
     // do the children
@@ -2022,13 +1977,11 @@ static void spell_print_tree(wordnode_T *root)
 // Returns an afffile_T, NULL for complete failure.
 static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 {
-  FILE *fd;
   char rline[MAXLINELEN];
   char *line;
   char *pc = NULL;
 #define MAXITEMCNT  30
   char *(items[MAXITEMCNT]);
-  int itemcnt;
   char *p;
   int lnum = 0;
   affheader_T *cur_aff = NULL;
@@ -2038,13 +1991,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
   char *low = NULL;
   char *fol = NULL;
   char *upp = NULL;
-  int do_rep;
-  int do_repsal;
-  int do_sal;
-  int do_mapline;
   bool found_map = false;
   hashitem_T *hi;
-  int l;
   int compminlen = 0;              // COMPOUNDMIN value
   int compsylmax = 0;              // COMPOUNDSYLMAX value
   int compoptions = 0;             // COMP_ flags
@@ -2057,7 +2005,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
   char *sofoto = NULL;             // SOFOTO value
 
   // Open the file.
-  fd = os_fopen(fname, "r");
+  FILE *fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return NULL;
@@ -2067,16 +2015,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
   spell_message(spin, IObuff);
 
   // Only do REP lines when not done in another .aff file already.
-  do_rep = GA_EMPTY(&spin->si_rep);
+  int do_rep = GA_EMPTY(&spin->si_rep);
 
   // Only do REPSAL lines when not done in another .aff file already.
-  do_repsal = GA_EMPTY(&spin->si_repsal);
+  int do_repsal = GA_EMPTY(&spin->si_repsal);
 
   // Only do SAL lines when not done in another .aff file already.
-  do_sal = GA_EMPTY(&spin->si_sal);
+  int do_sal = GA_EMPTY(&spin->si_sal);
 
   // Only do MAP lines when not done in another .aff file already.
-  do_mapline = GA_EMPTY(&spin->si_map);
+  int do_mapline = GA_EMPTY(&spin->si_map);
 
   // Allocate and init the afffile_T structure.
   afffile_T *aff = getroom(spin, sizeof(*aff), true);
@@ -2099,7 +2047,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
     if (spin->si_conv.vc_type != CONV_NONE) {
       pc = string_convert(&spin->si_conv, rline, NULL);
       if (pc == NULL) {
-        smsg(_("Conversion failure for word in %s line %d: %s"),
+        smsg(0, _("Conversion failure for word in %s line %d: %s"),
              fname, lnum, rline);
         continue;
       }
@@ -2111,7 +2059,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 
     // Split the line up in white separated items.  Put a NUL after each
     // item.
-    itemcnt = 0;
+    int itemcnt = 0;
     for (p = line;;) {
       while (*p != NUL && (uint8_t)(*p) <= ' ') {  // skip white space and CR/NL
         p++;
@@ -2143,10 +2091,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
     if (itemcnt > 0) {
       if (is_aff_rule(items, itemcnt, "SET", 2) && aff->af_enc == NULL) {
         // Setup for conversion from "ENC" to 'encoding'.
-        aff->af_enc = enc_canonize((char *)items[1]);
+        aff->af_enc = enc_canonize(items[1]);
         if (!spin->si_ascii
             && convert_setup(&spin->si_conv, aff->af_enc, p_enc) == FAIL) {
-          smsg(_("Conversion in %s not supported: from %s to %s"),
+          smsg(0, _("Conversion in %s not supported: from %s to %s"),
                fname, aff->af_enc, p_enc);
         }
         spin->si_conv.vc_fail = true;
@@ -2159,7 +2107,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         } else if (strcmp(items[1], "caplong") == 0) {
           aff->af_flagtype = AFT_CAPLONG;
         } else {
-          smsg(_("Invalid value for FLAG in %s line %d: %s"),
+          smsg(0, _("Invalid value for FLAG in %s line %d: %s"),
                fname, lnum, items[1]);
         }
         if (aff->af_rare != 0
@@ -2173,7 +2121,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
             || compflags != NULL
             || aff->af_suff.ht_used > 0
             || aff->af_pref.ht_used > 0) {
-          smsg(_("FLAG after using flags in %s line %d: %s"),
+          smsg(0, _("FLAG after using flags in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (spell_info_item(items[0]) && itemcnt > 1) {
@@ -2225,14 +2173,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
                  && aff->af_compforbid == 0) {
         aff->af_compforbid = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
         if (aff->af_pref.ht_used > 0) {
-          smsg(_("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
+          smsg(0,
+               _("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
                fname, lnum);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDPERMITFLAG", 2)
                  && aff->af_comppermit == 0) {
         aff->af_comppermit = affitem2flag(aff->af_flagtype, items[1], fname, lnum);
         if (aff->af_pref.ht_used > 0) {
-          smsg(_("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
+          smsg(0,
+               _("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
                fname, lnum);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDFLAG", 2)
@@ -2246,16 +2196,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
       } 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.
-        if (atoi((char *)items[1]) == 0) {
-          smsg(_("Wrong COMPOUNDRULES value in %s line %d: %s"),
+        if (atoi(items[1]) == 0) {
+          smsg(0, _("Wrong COMPOUNDRULES value in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2)) {
         // Don't use the first rule if it is a number.
-        if (compflags != NULL || *skipdigits((char *)items[1]) != NUL) {
+        if (compflags != NULL || *skipdigits(items[1]) != NUL) {
           // Concatenate this string to previously defined ones,
           // using a slash to separate them.
-          l = (int)strlen(items[1]) + 1;
+          int l = (int)strlen(items[1]) + 1;
           if (compflags != NULL) {
             l += (int)strlen(compflags) + 1;
           }
@@ -2269,23 +2219,23 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
                  && compmax == 0) {
-        compmax = atoi((char *)items[1]);
+        compmax = atoi(items[1]);
         if (compmax == 0) {
-          smsg(_("Wrong COMPOUNDWORDMAX value in %s line %d: %s"),
+          smsg(0, _("Wrong COMPOUNDWORDMAX value in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDMIN", 2)
                  && compminlen == 0) {
-        compminlen = atoi((char *)items[1]);
+        compminlen = atoi(items[1]);
         if (compminlen == 0) {
-          smsg(_("Wrong COMPOUNDMIN value in %s line %d: %s"),
+          smsg(0, _("Wrong COMPOUNDMIN value in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDSYLMAX", 2)
                  && compsylmax == 0) {
-        compsylmax = atoi((char *)items[1]);
+        compsylmax = atoi(items[1]);
         if (compsylmax == 0) {
-          smsg(_("Wrong COMPOUNDSYLMAX value in %s line %d: %s"),
+          smsg(0, _("Wrong COMPOUNDSYLMAX value in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDDUP", 1)) {
@@ -2297,8 +2247,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
       } else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDTRIPLE", 1)) {
         compoptions |= COMP_CHECKTRIPLE;
       } else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDPATTERN", 2)) {
-        if (atoi((char *)items[1]) == 0) {
-          smsg(_("Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"),
+        if (atoi(items[1]) == 0) {
+          smsg(0, _("Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"),
                fname, lnum, items[1]);
         }
       } else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDPATTERN", 3)) {
@@ -2350,15 +2300,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         // "S" flag on all but the last block, thus we check for that
         // and store it in ah_follows.
         xstrlcpy(key, items[1], AH_KEY_LEN);
-        hi = hash_find(tp, (char *)key);
+        hi = hash_find(tp, key);
         if (!HASHITEM_EMPTY(hi)) {
           cur_aff = HI2AH(hi);
           if (cur_aff->ah_combine != (*items[2] == 'Y')) {
-            smsg(_("Different combining flag in continued affix block in %s line %d: %s"),
+            smsg(0, _("Different combining flag in continued affix block in %s line %d: %s"),
                  fname, lnum, items[1]);
           }
           if (!cur_aff->ah_follows) {
-            smsg(_("Duplicate affix in %s line %d: %s"),
+            smsg(0, _("Duplicate affix in %s line %d: %s"),
                  fname, lnum, items[1]);
           }
         } else {
@@ -2376,9 +2326,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
               || cur_aff->ah_flag == aff->af_nosuggest
               || cur_aff->ah_flag == aff->af_needcomp
               || cur_aff->ah_flag == aff->af_comproot) {
-            smsg(_("Affix also used for "
-                   "BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST "
-                   "in %s line %d: %s"),
+            smsg(0, _("Affix also used for BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST "
+                      "in %s line %d: %s"),
                  fname, lnum, items[1]);
           }
           STRCPY(cur_aff->ah_key, items[1]);
@@ -2402,11 +2351,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         if (itemcnt > lasti
             && !aff->af_ignoreextra
             && *items[lasti] != '#') {
-          smsg(_(e_afftrailing), fname, lnum, items[lasti]);
+          smsg(0, _(e_afftrailing), fname, lnum, items[lasti]);
         }
 
         if (strcmp(items[2], "Y") != 0 && strcmp(items[2], "N") != 0) {
-          smsg(_("Expected Y or N in %s line %d: %s"),
+          smsg(0, _("Expected Y or N in %s line %d: %s"),
                fname, lnum, items[2]);
         }
 
@@ -2427,14 +2376,13 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
           }
         }
 
-        aff_todo = atoi((char *)items[3]);
+        aff_todo = atoi(items[3]);
       } else if ((strcmp(items[0], "PFX") == 0
                   || strcmp(items[0], "SFX") == 0)
                  && aff_todo > 0
                  && strcmp(cur_aff->ah_key, items[1]) == 0
                  && itemcnt >= 5) {
         affentry_T *aff_entry;
-        bool upper = false;
         int lasti = 5;
 
         // Myspell allows extra text after the item, but that might
@@ -2443,7 +2391,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         if (itemcnt > lasti && *items[lasti] != '#'
             && (strcmp(items[lasti], "-") != 0
                 || itemcnt != lasti + 1)) {
-          smsg(_(e_afftrailing), fname, lnum, items[lasti]);
+          smsg(0, _(e_afftrailing), fname, lnum, items[lasti]);
         }
 
         // New item for an affix letter.
@@ -2475,14 +2423,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
             char buf[MAXLINELEN];
 
             aff_entry->ae_cond = getroom_save(spin, items[4]);
-            if (*items[0] == 'P') {
-              sprintf(buf, "^%s", items[4]);  // NOLINT(runtime/printf)
-            } else {
-              sprintf(buf, "%s$", items[4]);  // NOLINT(runtime/printf)
-            }
+            snprintf(buf, sizeof(buf), *items[0] == 'P' ? "^%s" : "%s$", items[4]);
             aff_entry->ae_prog = vim_regcomp(buf, RE_MAGIC + RE_STRING + RE_STRICT);
             if (aff_entry->ae_prog == NULL) {
-              smsg(_("Broken condition in %s line %d: %s"),
+              smsg(0, _("Broken condition in %s line %d: %s"),
                    fname, lnum, items[4]);
             }
           }
@@ -2493,6 +2437,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
           // COMPOUNDFORBIDFLAG and COMPOUNDPERMITFLAG.
           if (*items[0] == 'P' && aff->af_pfxpostpone
               && aff_entry->ae_flags == NULL) {
+            bool upper = false;
             // When the chop string is one lower-case letter and
             // the add string ends in the upper-case letter we set
             // the "upper" flag, clear "ae_chop" and remove the
@@ -2502,10 +2447,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
                 && aff_entry->ae_add != NULL
                 && aff_entry->ae_chop[utfc_ptr2len(aff_entry->ae_chop)] ==
                 NUL) {
-              int c, c_up;
-
-              c = utf_ptr2char(aff_entry->ae_chop);
-              c_up = SPELL_TOUPPER(c);
+              int c = utf_ptr2char(aff_entry->ae_chop);
+              int c_up = SPELL_TOUPPER(c);
               if (c_up != c
                   && (aff_entry->ae_cond == NULL
                       || utf_ptr2char(aff_entry->ae_cond) == c)) {
@@ -2524,7 +2467,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
                     onecap_copy(items[4], buf, true);
                     aff_entry->ae_cond = getroom_save(spin, buf);
                     if (aff_entry->ae_cond != NULL) {
-                      sprintf(buf, "^%s", aff_entry->ae_cond);  // NOLINT(runtime/printf)
+                      snprintf(buf, MAXLINELEN, "^%s", aff_entry->ae_cond);
                       vim_regfree(aff_entry->ae_prog);
                       aff_entry->ae_prog = vim_regcomp(buf, RE_MAGIC + RE_STRING);
                     }
@@ -2535,8 +2478,6 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 
             if (aff_entry->ae_chop == NULL) {
               int idx;
-              char_u **pp;
-              int n;
 
               // Find a previously used condition.
               for (idx = spin->si_prefcond.ga_len - 1; idx >= 0; idx--) {
@@ -2548,9 +2489,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
               if (idx < 0) {
                 // Not found, add a new condition.
                 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);
+                char **pp = GA_APPEND_VIA_PTR(char *, &spin->si_prefcond);
+                *pp = (aff_entry->ae_cond == NULL)
+                      ? NULL : getroom_save(spin, aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
@@ -2562,7 +2503,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 
               // PFX_FLAGS is a negative number, so that
               // tree_add_word() knows this is the prefix tree.
-              n = PFX_FLAGS;
+              int n = PFX_FLAGS;
               if (!cur_aff->ah_combine) {
                 n |= WFP_NC;
               }
@@ -2575,7 +2516,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
               if (aff_entry->ae_compforbid) {
                 n |= WFP_COMPFORBID;
               }
-              tree_add_word(spin, (char_u *)p, spin->si_prefroot, n,
+              tree_add_word(spin, p, spin->si_prefroot, n,
                             idx, cur_aff->ah_newID);
               did_postpone_prefix = true;
             }
@@ -2597,7 +2538,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
                  || is_aff_rule(items, itemcnt, "REPSAL", 2)) {
         // Ignore REP/REPSAL count
         if (!isdigit((uint8_t)(*items[1]))) {
-          smsg(_("Expected REP(SAL) count in %s line %d"),
+          smsg(0, _("Expected REP(SAL) count in %s line %d"),
                fname, lnum);
         }
       } else if ((strcmp(items[0], "REP") == 0
@@ -2607,7 +2548,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
         // Myspell ignores extra arguments, we require it starts with
         // # to detect mistakes.
         if (itemcnt > 3 && items[3][0] != '#') {
-          smsg(_(e_afftrailing), fname, lnum, items[3]);
+          smsg(0, _(e_afftrailing), fname, lnum, items[3]);
         }
         if (items[0][3] == 'S' ? do_repsal : do_rep) {
           // Replace underscore with space (can't include a space
@@ -2632,27 +2573,25 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
           // First line contains the count.
           found_map = true;
           if (!isdigit((uint8_t)(*items[1]))) {
-            smsg(_("Expected MAP count in %s line %d"),
+            smsg(0, _("Expected MAP count in %s line %d"),
                  fname, lnum);
           }
         } else if (do_mapline) {
-          int c;
-
           // Check that every character appears only once.
           for (p = items[1]; *p != NUL;) {
-            c = mb_ptr2char_adv((const char **)&p);
+            int c = mb_ptr2char_adv((const char **)&p);
             if ((!GA_EMPTY(&spin->si_map)
                  && vim_strchr(spin->si_map.ga_data, c)
                  != NULL)
                 || vim_strchr(p, c) != NULL) {
-              smsg(_("Duplicate character in MAP in %s line %d"),
+              smsg(0, _("Duplicate character in MAP in %s line %d"),
                    fname, lnum);
             }
           }
 
           // We simply concatenate all the MAP strings, separated by
           // slashes.
-          ga_concat(&spin->si_map, (char *)items[1]);
+          ga_concat(&spin->si_map, items[1]);
           ga_append(&spin->si_map, '/');
         }
       }
@@ -2671,7 +2610,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
             // when "to" is "_" it means empty
             add_fromto(spin, &spin->si_sal, items[1],
                        strcmp(items[2], "_") == 0 ? ""
-                       : items[2]);
+                                                  : items[2]);
           }
         }
       } else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
@@ -2681,16 +2620,14 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
                  && sofoto == NULL) {
         sofoto = 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]))) {
+        for (int i = 1; i < itemcnt; i++) {
+          if (HASHITEM_EMPTY(hash_find(&spin->si_commonwords, items[i]))) {
             p = xstrdup(items[i]);
             hash_add(&spin->si_commonwords, p);
           }
         }
       } else {
-        smsg(_("Unrecognized or duplicate item in %s line %d: %s"),
+        smsg(0, _("Unrecognized or duplicate item in %s line %d: %s"),
              fname, lnum, items[0]);
       }
     }
@@ -2722,7 +2659,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 
   if (compsylmax != 0) {
     if (syllable == NULL) {
-      smsg("%s", _("COMPOUNDSYLMAX used without SYLLABLE"));
+      smsg(0, "%s", _("COMPOUNDSYLMAX used without SYLLABLE"));
     }
     aff_check_number(spin->si_compsylmax, compsylmax, "COMPOUNDSYLMAX");
     spin->si_compsylmax = compsylmax;
@@ -2740,11 +2677,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
   // Check that we didn't use too many renumbered flags.
   if (spin->si_newcompID < spin->si_newprefID) {
     if (spin->si_newcompID == 127 || spin->si_newcompID == 255) {
-      msg(_("Too many postponed prefixes"));
+      msg(_("Too many postponed prefixes"), 0);
     } else if (spin->si_newprefID == 0 || spin->si_newprefID == 127) {
-      msg(_("Too many compound flags"));
+      msg(_("Too many compound flags"), 0);
     } else {
-      msg(_("Too many postponed prefixes and/or compound flags"));
+      msg(_("Too many postponed prefixes and/or compound flags"), 0);
     }
   }
 
@@ -2755,10 +2692,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname)
 
   if (sofofrom != NULL || sofoto != NULL) {
     if (sofofrom == NULL || sofoto == NULL) {
-      smsg(_("Missing SOFO%s line in %s"),
+      smsg(0, _("Missing SOFO%s line in %s"),
            sofofrom == NULL ? "FROM" : "TO", fname);
     } else if (!GA_EMPTY(&spin->si_sal)) {
-      smsg(_("Both SAL and SOFO lines in %s"), fname);
+      smsg(0, _("Both SAL and SOFO lines in %s"), fname);
     } else {
       aff_check_string(spin->si_sofofr, sofofrom, "SOFOFROM");
       aff_check_string(spin->si_sofoto, sofoto, "SOFOTO");
@@ -2790,18 +2727,14 @@ static bool is_aff_rule(char **items, int itemcnt, char *rulename, int mincount)
 // ae_flags to ae_comppermit and ae_compforbid.
 static void aff_process_flags(afffile_T *affile, affentry_T *entry)
 {
-  char *p;
-  char_u *prevp;
-  unsigned flag;
-
   if (entry->ae_flags != NULL
       && (affile->af_compforbid != 0 || affile->af_comppermit != 0)) {
-    for (p = entry->ae_flags; *p != NUL;) {
-      prevp = (char_u *)p;
-      flag = get_affitem(affile->af_flagtype, &p);
+    for (char *p = entry->ae_flags; *p != NUL;) {
+      char *prevp = p;
+      unsigned flag = get_affitem(affile->af_flagtype, &p);
       if (flag == affile->af_comppermit || flag == affile->af_compforbid) {
-        STRMOVE(prevp, (char *)p);
-        p = (char *)prevp;
+        STRMOVE(prevp, p);
+        p = prevp;
         if (flag == affile->af_comppermit) {
           entry->ae_comppermit = true;
         } else {
@@ -2833,21 +2766,20 @@ static bool spell_info_item(char *s)
 // returns zero for failure.
 static unsigned affitem2flag(int flagtype, char *item, char *fname, int lnum)
 {
-  unsigned res;
   char *p = item;
 
-  res = get_affitem(flagtype, &p);
+  unsigned res = get_affitem(flagtype, &p);
   if (res == 0) {
     if (flagtype == AFT_NUM) {
-      smsg(_("Flag is not a number in %s line %d: %s"),
+      smsg(0, _("Flag is not a number in %s line %d: %s"),
            fname, lnum, item);
     } else {
-      smsg(_("Illegal flag in %s line %d: %s"),
+      smsg(0, _("Illegal flag in %s line %d: %s"),
            fname, lnum, item);
     }
   }
   if (*p != NUL) {
-    smsg(_(e_affname), fname, lnum, item);
+    smsg(0, _(e_affname), fname, lnum, item);
     return 0;
   }
 
@@ -2889,44 +2821,38 @@ static unsigned get_affitem(int flagtype, char **pp)
 /// they fit in one byte.
 static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags)
 {
-  char *p;
-  char *prevp;
-  unsigned flag;
   compitem_T *ci;
   int id;
-  int len;
-  char_u *tp;
   char key[AH_KEY_LEN];
-  hashitem_T *hi;
 
   // 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;
+  int len = (int)strlen(compflags) + 1;
   if (spin->si_compflags != NULL) {
     len += (int)strlen(spin->si_compflags) + 1;
   }
-  p = getroom(spin, (size_t)len, false);
+  char *p = getroom(spin, (size_t)len, false);
   if (spin->si_compflags != NULL) {
     STRCPY(p, spin->si_compflags);
     STRCAT(p, "/");
   }
   spin->si_compflags = p;
-  tp = (char_u *)p + strlen(p);
+  uint8_t *tp = (uint8_t *)p + strlen(p);
 
   for (p = compflags; *p != NUL;) {
     if (vim_strchr("/?*+[]", (uint8_t)(*p)) != NULL) {
       // Copy non-flag characters directly.
-      *tp++ = (char_u)(*p++);
+      *tp++ = (uint8_t)(*p++);
     } else {
       // First get the flag number, also checks validity.
-      prevp = p;
-      flag = get_affitem(aff->af_flagtype, &p);
+      char *prevp = p;
+      unsigned flag = get_affitem(aff->af_flagtype, &p);
       if (flag != 0) {
         // Find the flag in the hashtable.  If it was used before, use
         // the existing ID.  Otherwise add a new entry.
         xstrlcpy(key, prevp, (size_t)(p - prevp) + 1);
-        hi = hash_find(&aff->af_comp, (char *)key);
+        hashitem_T *hi = hash_find(&aff->af_comp, key);
         if (!HASHITEM_EMPTY(hi)) {
           id = HI2CI(hi)->ci_newID;
         } else {
@@ -2940,9 +2866,9 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags
             id = spin->si_newcompID--;
           } while (vim_strchr("/?*+[]\\-^", id) != NULL);
           ci->ci_newID = id;
-          hash_add(&aff->af_comp, (char *)ci->ci_key);
+          hash_add(&aff->af_comp, ci->ci_key);
         }
-        *tp++ = (char_u)id;
+        *tp++ = (uint8_t)id;
       }
       if (aff->af_flagtype == AFT_NUM && *p == ',') {
         p++;
@@ -2968,17 +2894,14 @@ static void check_renumber(spellinfo_T *spin)
 // Returns true if flag "flag" appears in affix list "afflist".
 static bool flag_in_afflist(int flagtype, char *afflist, unsigned flag)
 {
-  char *p;
-  unsigned n;
-
   switch (flagtype) {
   case AFT_CHAR:
     return vim_strchr(afflist, (int)flag) != NULL;
 
   case AFT_CAPLONG:
   case AFT_LONG:
-    for (p = afflist; *p != NUL;) {
-      n = (unsigned)mb_ptr2char_adv((const char **)&p);
+    for (char *p = afflist; *p != NUL;) {
+      unsigned n = (unsigned)mb_ptr2char_adv((const char **)&p);
       if ((flagtype == AFT_LONG || (n >= 'A' && n <= 'Z'))
           && *p != NUL) {
         n = (unsigned)mb_ptr2char_adv((const char **)&p) + (n << 16);
@@ -2990,10 +2913,10 @@ static bool flag_in_afflist(int flagtype, char *afflist, unsigned flag)
     break;
 
   case AFT_NUM:
-    for (p = afflist; *p != NUL;) {
+    for (char *p = afflist; *p != NUL;) {
       int digits = getdigits_int(&p, true, 0);
       assert(digits >= 0);
-      n = (unsigned int)digits;
+      unsigned n = (unsigned)digits;
       if (n == 0) {
         n = ZERO_FLAG;
       }
@@ -3013,7 +2936,7 @@ static bool flag_in_afflist(int flagtype, char *afflist, unsigned flag)
 static void aff_check_number(int spinval, int affval, char *name)
 {
   if (spinval != 0 && spinval != affval) {
-    smsg(_("%s value differs from what is used in another .aff file"),
+    smsg(0, _("%s value differs from what is used in another .aff file"),
          name);
   }
 }
@@ -3022,7 +2945,7 @@ static void aff_check_number(int spinval, int affval, char *name)
 static void aff_check_string(char *spinval, char *affval, char *name)
 {
   if (spinval != NULL && strcmp(spinval, affval) != 0) {
-    smsg(_("%s value differs from what is used in another .aff file"),
+    smsg(0, _("%s value differs from what is used in another .aff file"),
          name);
   }
 }
@@ -3059,22 +2982,16 @@ static bool sal_to_bool(char *s)
 // Free the structure filled by spell_read_aff().
 static void spell_free_aff(afffile_T *aff)
 {
-  hashtab_T *ht;
-  hashitem_T *hi;
-  int todo;
-  affheader_T *ah;
-  affentry_T *ae;
-
   xfree(aff->af_enc);
 
   // All this trouble to free the "ae_prog" items...
-  for (ht = &aff->af_pref;; ht = &aff->af_suff) {
-    todo = (int)ht->ht_used;
-    for (hi = ht->ht_array; todo > 0; hi++) {
+  for (hashtab_T *ht = &aff->af_pref;; ht = &aff->af_suff) {
+    int todo = (int)ht->ht_used;
+    for (hashitem_T *hi = ht->ht_array; todo > 0; hi++) {
       if (!HASHITEM_EMPTY(hi)) {
         todo--;
-        ah = HI2AH(hi);
-        for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next) {
+        affheader_T *ah = HI2AH(hi);
+        for (affentry_T *ae = ah->ah_first; ae != NULL; ae = ae->ae_next) {
           vim_regfree(ae->ae_prog);
         }
       }
@@ -3095,28 +3012,18 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
 {
   hashtab_T ht;
   char line[MAXLINELEN];
-  char_u *p;
-  char_u *afflist;
-  char_u store_afflist[MAXWLEN];
-  int pfxlen;
-  bool need_affix;
-  char *dw;
-  char_u *pc;
-  char_u *w;
-  int l;
-  hash_T hash;
-  hashitem_T *hi;
-  FILE *fd;
+  char store_afflist[MAXWLEN];
+  char *pc;
+  char *w;
   int lnum = 1;
   int non_ascii = 0;
   int retval = OK;
-  char_u message[MAXLINELEN + MAXWLEN];
-  int flags;
+  char message[MAXLINELEN + MAXWLEN];
   int duplicate = 0;
   Timestamp last_msg_time = 0;
 
   // Open the file.
-  fd = os_fopen(fname, "r");
+  FILE *fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return FAIL;
@@ -3133,14 +3040,14 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
   spin->si_msg_count = 999999;
 
   // Read and ignore the first line: word count.
-  if (vim_fgets((char *)line, MAXLINELEN, fd) || !ascii_isdigit(*skipwhite((char *)line))) {
+  if (vim_fgets(line, MAXLINELEN, fd) || !ascii_isdigit(*skipwhite(line))) {
     semsg(_("E760: No word count in %s"), fname);
   }
 
   // Read all the lines in the file one by one.
   // The words are converted to 'encoding' here, before being added to
   // the hashtable.
-  while (!vim_fgets((char *)line, MAXLINELEN, fd) && !got_int) {
+  while (!vim_fgets(line, MAXLINELEN, fd) && !got_int) {
     line_breakcheck();
     lnum++;
     if (line[0] == '#' || line[0] == '/') {
@@ -3148,8 +3055,8 @@ static int spell_read_dic(spellinfo_T *spin, char *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);
-    while (l > 0 && line[l - 1] <= ' ') {
+    int l = (int)strlen(line);
+    while (l > 0 && (uint8_t)line[l - 1] <= ' ') {
       l--;
     }
     if (l == 0) {
@@ -3159,24 +3066,24 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
 
     // Convert from "SET" to 'encoding' when needed.
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = (char_u *)string_convert(&spin->si_conv, (char *)line, NULL);
+      pc = string_convert(&spin->si_conv, line, NULL);
       if (pc == NULL) {
-        smsg(_("Conversion failure for word in %s line %d: %s"),
+        smsg(0, _("Conversion failure for word in %s line %d: %s"),
              fname, lnum, line);
         continue;
       }
       w = pc;
     } else {
       pc = NULL;
-      w = (char_u *)line;
+      w = line;
     }
 
     // Truncate the word at the "/", set "afflist" to what follows.
     // Replace "\/" by "/" and "\\" by "\".
-    afflist = NULL;
-    for (p = w; *p != NUL; MB_PTR_ADV(p)) {
+    char *afflist = NULL;
+    for (char *p = w; *p != NUL; MB_PTR_ADV(p)) {
       if (*p == '\\' && (p[1] == '\\' || p[1] == '/')) {
-        STRMOVE(p, (char *)p + 1);
+        STRMOVE(p, p + 1);
       } else if (*p == '/') {
         *p = NUL;
         afflist = p + 1;
@@ -3185,7 +3092,7 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
     }
 
     // Skip non-ASCII words when "spin->si_ascii" is true.
-    if (spin->si_ascii && has_non_ascii((char *)w)) {
+    if (spin->si_ascii && has_non_ascii(w)) {
       non_ascii++;
       xfree(pc);
       continue;
@@ -3197,11 +3104,11 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
       spin->si_msg_count = 0;
       if (os_time() > last_msg_time) {
         last_msg_time = os_time();
-        vim_snprintf((char *)message, sizeof(message),
-                     _("line %6d, word %6ld - %s"),
+        vim_snprintf(message, sizeof(message),
+                     _("line %6d, word %6d - %s"),
                      lnum, spin->si_foldwcount + spin->si_keepwcount, w);
         msg_start();
-        msg_outtrans_long_attr((char *)message, 0);
+        msg_outtrans_long(message, 0);
         msg_clr_eos();
         msg_didout = false;
         msg_col = 0;
@@ -3210,21 +3117,21 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
     }
 
     // Store the word in the hashtable to be able to find duplicates.
-    dw = getroom_save(spin, (char *)w);
+    char *dw = getroom_save(spin, w);
     if (dw == NULL) {
       retval = FAIL;
       xfree(pc);
       break;
     }
 
-    hash = hash_hash(dw);
-    hi = hash_lookup(&ht, (const char *)dw, strlen(dw), hash);
+    hash_T hash = hash_hash(dw);
+    hashitem_T *hi = hash_lookup(&ht, dw, strlen(dw), hash);
     if (!HASHITEM_EMPTY(hi)) {
       if (p_verbose > 0) {
-        smsg(_("Duplicate word in %s line %d: %s"),
+        smsg(0, _("Duplicate word in %s line %d: %s"),
              fname, lnum, dw);
       } else if (duplicate == 0) {
-        smsg(_("First duplicate word in %s line %d: %s"),
+        smsg(0, _("First duplicate word in %s line %d: %s"),
              fname, lnum, dw);
       }
       duplicate++;
@@ -3232,51 +3139,51 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
       hash_add_item(&ht, hi, dw, hash);
     }
 
-    flags = 0;
+    int flags = 0;
     store_afflist[0] = NUL;
-    pfxlen = 0;
-    need_affix = false;
+    int pfxlen = 0;
+    bool need_affix = false;
     if (afflist != NULL) {
       // Extract flags from the affix list.
-      flags |= get_affix_flags(affile, (char *)afflist);
+      flags |= get_affix_flags(affile, afflist);
 
       if (affile->af_needaffix != 0
-          && flag_in_afflist(affile->af_flagtype, (char *)afflist,
+          && flag_in_afflist(affile->af_flagtype, afflist,
                              affile->af_needaffix)) {
         need_affix = true;
       }
 
       if (affile->af_pfxpostpone) {
         // Need to store the list of prefix IDs with the word.
-        pfxlen = get_pfxlist(affile, (char *)afflist, store_afflist);
+        pfxlen = get_pfxlist(affile, afflist, store_afflist);
       }
 
       if (spin->si_compflags != NULL) {
         // Need to store the list of compound flags with the word.
         // Concatenate them to the list of prefix IDs.
-        get_compflags(affile, (char *)afflist, store_afflist + pfxlen);
+        get_compflags(affile, afflist, store_afflist + pfxlen);
       }
     }
 
     // Add the word to the word tree(s).
     if (store_word(spin, dw, flags, spin->si_region,
-                   (char *)store_afflist, need_affix) == FAIL) {
+                   store_afflist, need_affix) == FAIL) {
       retval = FAIL;
     }
 
     if (afflist != NULL) {
       // Find all matching suffixes and add the resulting words.
       // Additionally do matching prefixes that combine.
-      if (store_aff_word(spin, dw, (char *)afflist, affile,
+      if (store_aff_word(spin, dw, afflist, affile,
                          &affile->af_suff, &affile->af_pref,
-                         CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
+                         CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) {
         retval = FAIL;
       }
 
       // Find all matching prefixes and add the resulting words.
-      if (store_aff_word(spin, dw, (char *)afflist, affile,
+      if (store_aff_word(spin, dw, afflist, affile,
                          &affile->af_pref, NULL,
-                         CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
+                         CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) {
         retval = FAIL;
       }
     }
@@ -3285,10 +3192,10 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile)
   }
 
   if (duplicate > 0) {
-    smsg(_("%d duplicate word(s) in %s"), duplicate, fname);
+    smsg(0, _("%d duplicate word(s) in %s"), duplicate, fname);
   }
   if (spin->si_ascii && non_ascii > 0) {
-    smsg(_("Ignored %d word(s) with non-ASCII characters in %s"),
+    smsg(0, _("Ignored %d word(s) with non-ASCII characters in %s"),
          non_ascii, fname);
   }
   hash_clear(&ht);
@@ -3338,26 +3245,22 @@ static int get_affix_flags(afffile_T *affile, char *afflist)
 // Used for PFXPOSTPONE.
 // Put the resulting flags in "store_afflist[MAXWLEN]" with a terminating NUL
 // and return the number of affixes.
-static int get_pfxlist(afffile_T *affile, char *afflist, char_u *store_afflist)
+static int get_pfxlist(afffile_T *affile, char *afflist, char *store_afflist)
 {
-  char *p;
-  char *prevp;
   int cnt = 0;
-  int id;
   char key[AH_KEY_LEN];
-  hashitem_T *hi;
 
-  for (p = afflist; *p != NUL;) {
-    prevp = p;
+  for (char *p = afflist; *p != NUL;) {
+    char *prevp = p;
     if (get_affitem(affile->af_flagtype, &p) != 0) {
       // A flag is a postponed prefix flag if it appears in "af_pref"
       // and its ID is not zero.
       xstrlcpy(key, prevp, (size_t)(p - prevp) + 1);
-      hi = hash_find(&affile->af_pref, (char *)key);
+      hashitem_T *hi = hash_find(&affile->af_pref, key);
       if (!HASHITEM_EMPTY(hi)) {
-        id = HI2AH(hi)->ah_newID;
+        int id = HI2AH(hi)->ah_newID;
         if (id != 0) {
-          store_afflist[cnt++] = (char_u)id;
+          store_afflist[cnt++] = (char)(uint8_t)id;
         }
       }
     }
@@ -3373,22 +3276,19 @@ static int get_pfxlist(afffile_T *affile, char *afflist, char_u *store_afflist)
 // Get the list of compound IDs from the affix list "afflist" that are used
 // for compound words.
 // Puts the flags in "store_afflist[]".
-static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflist)
+static void get_compflags(afffile_T *affile, char *afflist, char *store_afflist)
 {
-  char *p;
-  char *prevp;
   int cnt = 0;
   char key[AH_KEY_LEN];
-  hashitem_T *hi;
 
-  for (p = afflist; *p != NUL;) {
-    prevp = p;
+  for (char *p = afflist; *p != NUL;) {
+    char *prevp = p;
     if (get_affitem(affile->af_flagtype, &p) != 0) {
       // A flag is a compound flag if it appears in "af_comp".
       xstrlcpy(key, prevp, (size_t)(p - prevp) + 1);
-      hi = hash_find(&affile->af_comp, (char *)key);
+      hashitem_T *hi = hash_find(&affile->af_comp, key);
       if (!HASHITEM_EMPTY(hi)) {
-        store_afflist[cnt++] = (char_u)HI2CI(hi)->ci_newID;
+        store_afflist[cnt++] = (char)(uint8_t)HI2CI(hi)->ci_newID;
       }
     }
     if (affile->af_flagtype == AFT_NUM && *p == ',') {
@@ -3418,28 +3318,19 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
                           hashtab_T *ht, hashtab_T *xht, int condit, int flags, char *pfxlist,
                           int pfxlen)
 {
-  int todo;
-  hashitem_T *hi;
-  affheader_T *ah;
   affentry_T *ae;
   char newword[MAXWLEN];
   int retval = OK;
-  int i, j;
-  char *p;
-  int use_flags;
-  char *use_pfxlist;
-  int use_pfxlen;
-  bool need_affix;
-  char_u store_afflist[MAXWLEN];
+  int j;
+  char store_afflist[MAXWLEN];
   char pfx_pfxlist[MAXWLEN];
   size_t wordlen = strlen(word);
-  int use_condit;
 
-  todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0 && retval == OK; hi++) {
+  int todo = (int)ht->ht_used;
+  for (hashitem_T *hi = ht->ht_array; todo > 0 && retval == OK; hi++) {
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
-      ah = HI2AH(hi);
+      affheader_T *ah = HI2AH(hi);
 
       // Check that the affix combines, if required, and that the word
       // supports this affix.
@@ -3464,7 +3355,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               && (ae->ae_chop == NULL
                   || 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, word, 0))
               && (((condit & CONDIT_CFIX) == 0)
                   == ((condit & CONDIT_AFF) == 0
                       || ae->ae_flags == NULL
@@ -3478,10 +3369,10 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               } else {
                 xstrlcpy(newword, ae->ae_add, MAXWLEN);
               }
-              p = word;
+              char *p = word;
               if (ae->ae_chop != NULL) {
                 // Skip chop string.
-                i = mb_charlen(ae->ae_chop);
+                int i = mb_charlen(ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_ADV(p);
                 }
@@ -3492,8 +3383,8 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               xstrlcpy(newword, word, MAXWLEN);
               if (ae->ae_chop != NULL) {
                 // Remove chop string.
-                p = newword + strlen(newword);
-                i = mb_charlen(ae->ae_chop);
+                char *p = newword + strlen(newword);
+                int i = mb_charlen(ae->ae_chop);
                 for (; i > 0; i--) {
                   MB_PTR_BACK(newword, p);
                 }
@@ -3504,11 +3395,11 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               }
             }
 
-            use_flags = flags;
-            use_pfxlist = pfxlist;
-            use_pfxlen = pfxlen;
-            need_affix = false;
-            use_condit = condit | CONDIT_COMB | CONDIT_AFF;
+            int use_flags = flags;
+            char *use_pfxlist = pfxlist;
+            int use_pfxlen = pfxlen;
+            bool need_affix = false;
+            int use_condit = condit | CONDIT_COMB | CONDIT_AFF;
             if (ae->ae_flags != NULL) {
               // Extract flags from the affix list.
               use_flags |= get_affix_flags(affile, ae->ae_flags);
@@ -3539,11 +3430,11 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
                 } else {
                   use_pfxlen = 0;
                 }
-                use_pfxlist = (char *)store_afflist;
+                use_pfxlist = store_afflist;
 
                 // Combine the prefix IDs. Avoid adding the
                 // same ID twice.
-                for (i = 0; i < pfxlen; i++) {
+                for (int i = 0; i < pfxlen; i++) {
                   for (j = 0; j < use_pfxlen; j++) {
                     if (pfxlist[i] == use_pfxlist[j]) {
                       break;
@@ -3557,7 +3448,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
                 if (spin->si_compflags != NULL) {
                   // Get compound IDS from the affix list.
                   get_compflags(affile, ae->ae_flags,
-                                (char_u *)use_pfxlist + use_pfxlen);
+                                use_pfxlist + use_pfxlen);
                 } else {
                   use_pfxlist[use_pfxlen] = NUL;
                 }
@@ -3565,7 +3456,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
                 // Combine the list of compound flags.
                 // Concatenate them to the prefix IDs list.
                 // Avoid adding the same ID twice.
-                for (i = pfxlen; pfxlist[i] != NUL; i++) {
+                for (int i = pfxlen; pfxlist[i] != NUL; i++) {
                   for (j = use_pfxlen; use_pfxlist[j] != NUL; j++) {
                     if (pfxlist[i] == use_pfxlist[j]) {
                       break;
@@ -3624,7 +3515,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
               if (store_aff_word(spin, newword, ae->ae_flags,
                                  affile, &affile->af_suff, xht,
                                  use_condit & (xht == NULL
-                                               ? ~0 :  ~CONDIT_SUF),
+                                               ? ~0 : ~CONDIT_SUF),
                                  use_flags, use_pfxlist, pfxlen) == FAIL) {
                 retval = FAIL;
               }
@@ -3660,21 +3551,16 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_
 // Read a file with a list of words.
 static int spell_read_wordfile(spellinfo_T *spin, char *fname)
 {
-  FILE *fd;
-  long lnum = 0;
+  linenr_T lnum = 0;
   char rline[MAXLINELEN];
   char *line;
-  char_u *pc = NULL;
-  char_u *p;
-  int l;
+  char *pc = NULL;
   int retval = OK;
   bool did_word = false;
   int non_ascii = 0;
-  int flags;
-  int regionmask;
 
   // Open the file.
-  fd = os_fopen(fname, "r");
+  FILE *fd = os_fopen(fname, "r");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return FAIL;
@@ -3694,7 +3580,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
     }
 
     // Remove CR, LF and white space from the end.
-    l = (int)strlen(rline);
+    int l = (int)strlen(rline);
     while (l > 0 && (uint8_t)rline[l - 1] <= ' ') {
       l--;
     }
@@ -3706,13 +3592,13 @@ static int spell_read_wordfile(spellinfo_T *spin, char *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, rline, NULL);
+      pc = string_convert(&spin->si_conv, rline, NULL);
       if (pc == NULL) {
-        smsg(_("Conversion failure for word in %s line %ld: %s"),
+        smsg(0, _("Conversion failure for word in %s line %" PRIdLINENR ": %s"),
              fname, lnum, rline);
         continue;
       }
-      line = (char *)pc;
+      line = pc;
     } else {
       pc = NULL;
       line = rline;
@@ -3722,10 +3608,10 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
       line++;
       if (strncmp(line, "encoding=", 9) == 0) {
         if (spin->si_conv.vc_type != CONV_NONE) {
-          smsg(_("Duplicate /encoding= line ignored in %s line %ld: %s"),
+          smsg(0, _("Duplicate /encoding= line ignored in %s line %" PRIdLINENR ": %s"),
                fname, lnum, line - 1);
         } else if (did_word) {
-          smsg(_("/encoding= line after word ignored in %s line %ld: %s"),
+          smsg(0, _("/encoding= line after word ignored in %s line %" PRIdLINENR ": %s"),
                fname, lnum, line - 1);
         } else {
           char *enc;
@@ -3735,7 +3621,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
           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"),
+            smsg(0, _("Conversion in %s not supported: from %s to %s"),
                  fname, line, p_enc);
           }
           xfree(enc);
@@ -3746,12 +3632,12 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
 
       if (strncmp(line, "regions=", 8) == 0) {
         if (spin->si_region_count > 1) {
-          smsg(_("Duplicate /regions= line ignored in %s line %ld: %s"),
+          smsg(0, _("Duplicate /regions= line ignored in %s line %" PRIdLINENR ": %s"),
                fname, lnum, line);
         } else {
           line += 8;
           if (strlen(line) > MAXREGIONS * 2) {
-            smsg(_("Too many regions in %s line %ld: %s"),
+            smsg(0, _("Too many regions in %s line %" PRIdLINENR ": %s"),
                  fname, lnum, line);
           } else {
             spin->si_region_count = (int)strlen(line) / 2;
@@ -3764,16 +3650,16 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
         continue;
       }
 
-      smsg(_("/ line ignored in %s line %ld: %s"),
+      smsg(0, _("/ line ignored in %s line %" PRIdLINENR ": %s"),
            fname, lnum, line - 1);
       continue;
     }
 
-    flags = 0;
-    regionmask = spin->si_region;
+    int flags = 0;
+    int regionmask = spin->si_region;
 
     // Check for flags and region after a slash.
-    p = (char_u *)vim_strchr(line, '/');
+    char *p = vim_strchr(line, '/');
     if (p != NULL) {
       *p++ = NUL;
       while (*p != NUL) {
@@ -3783,21 +3669,21 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
           flags |= WF_BANNED;
         } else if (*p == '?') {                  // Rare word.
           flags |= WF_RARE;
-        } else if (ascii_isdigit(*p)) {              // region number(s)
+        } else if (ascii_isdigit((uint8_t)(*p))) {              // region number(s)
           if ((flags & WF_REGION) == 0) {           // first one
             regionmask = 0;
           }
           flags |= WF_REGION;
 
-          l = *p - '0';
+          l = (uint8_t)(*p) - '0';
           if (l == 0 || l > spin->si_region_count) {
-            smsg(_("Invalid region nr in %s line %ld: %s"),
+            smsg(0, _("Invalid region nr in %s line %" PRIdLINENR ": %s"),
                  fname, lnum, p);
             break;
           }
           regionmask |= 1 << (l - 1);
         } else {
-          smsg(_("Unrecognized flags in %s line %ld: %s"),
+          smsg(0, _("Unrecognized flags in %s line %" PRIdLINENR ": %s"),
                fname, lnum, p);
           break;
         }
@@ -3842,7 +3728,6 @@ static int spell_read_wordfile(spellinfo_T *spin, char *fname)
 static void *getroom(spellinfo_T *spin, size_t len, bool align)
   FUNC_ATTR_NONNULL_RET
 {
-  char_u *p;
   sblock_T *bl = spin->si_blocks;
 
   assert(len <= SBLOCKSIZE);
@@ -3855,14 +3740,14 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
 
   if (bl == NULL || (size_t)bl->sb_used + len > SBLOCKSIZE) {
     // Allocate a block of memory. It is not freed until much later.
-    bl = xcalloc(1, (sizeof(sblock_T) + SBLOCKSIZE));
+    bl = xcalloc(1, offsetof(sblock_T, sb_data) + SBLOCKSIZE + 1);
     bl->sb_next = spin->si_blocks;
     spin->si_blocks = bl;
     bl->sb_used = 0;
     spin->si_blocks_cnt++;
   }
 
-  p = bl->sb_data + bl->sb_used;
+  char *p = bl->sb_data + bl->sb_used;
   bl->sb_used += (int)len;
 
   return p;
@@ -3880,10 +3765,8 @@ static char *getroom_save(spellinfo_T *spin, char *s)
 // Free the list of allocated sblock_T.
 static void free_blocks(sblock_T *bl)
 {
-  sblock_T *next;
-
   while (bl != NULL) {
-    next = bl->sb_next;
+    sblock_T *next = bl->sb_next;
     xfree(bl);
     bl = next;
   }
@@ -3901,7 +3784,7 @@ static wordnode_T *wordtree_alloc(spellinfo_T *spin)
 /// Control characters and trailing '/' are invalid.  Space is OK.
 static bool valid_spell_word(const char *word, const char *end)
 {
-  if (!utf_valid_string((char_u *)word, (char_u *)end)) {
+  if (!utf_valid_string(word, end)) {
     return false;
   }
   for (const char *p = word; *p != NUL && p < end; p += utfc_ptr2len(p)) {
@@ -3929,7 +3812,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
 {
   int len = (int)strlen(word);
   int ct = captype(word, word + len);
-  char_u foldword[MAXWLEN];
+  char foldword[MAXWLEN];
   int res = OK;
 
   // Avoid adding illegal bytes to the word tree.
@@ -3937,8 +3820,8 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
     return FAIL;
   }
 
-  (void)spell_casefold(curwin, word, len, (char *)foldword, MAXWLEN);
-  for (const char_u *p = (char_u *)pfxlist; res == OK; p++) {
+  (void)spell_casefold(curwin, word, len, foldword, MAXWLEN);
+  for (const char *p = pfxlist; res == OK; p++) {
     if (!need_affix || (p != NULL && *p != NUL)) {
       res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
                           region, p == NULL ? 0 : *p);
@@ -3950,9 +3833,9 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
   spin->si_foldwcount++;
 
   if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
-    for (const char_u *p = (char_u *)pfxlist; res == OK; p++) {
+    for (const char *p = pfxlist; res == OK; p++) {
       if (!need_affix || (p != NULL && *p != NUL)) {
-        res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags,
+        res = tree_add_word(spin, word, spin->si_keeproot, flags,
                             region, p == NULL ? 0 : *p);
       }
       if (p == NULL || *p == NUL) {
@@ -3968,26 +3851,23 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons
 // When "flags" < 0 we are adding to the prefix tree where "flags" is used for
 // "rare" and "region" is the condition nr.
 // Returns FAIL when out of memory.
-static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root, int flags,
+static int tree_add_word(spellinfo_T *spin, const char *word, wordnode_T *root, int flags,
                          int region, int affixID)
 {
   wordnode_T *node = root;
-  wordnode_T *np;
-  wordnode_T *copyp, **copyprev;
   wordnode_T **prev = NULL;
-  int i;
 
   // Add each byte of the word to the tree, including the NUL at the end.
-  for (i = 0;; i++) {
+  for (int i = 0;; i++) {
     // When there is more than one reference to this node we need to make
     // a copy, so that we can modify it.  Copy the whole list of siblings
     // (we don't optimize for a partly shared list of siblings).
     if (node != NULL && node->wn_refs > 1) {
       node->wn_refs--;
-      copyprev = prev;
-      for (copyp = node; copyp != NULL; copyp = copyp->wn_sibling) {
+      wordnode_T **copyprev = prev;
+      for (wordnode_T *copyp = node; copyp != NULL; copyp = copyp->wn_sibling) {
         // Allocate a new node and copy the info.
-        np = get_wordnode(spin);
+        wordnode_T *np = get_wordnode(spin);
         if (np == NULL) {
           return FAIL;
         }
@@ -4021,7 +3901,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
     // higher byte value.  For zero bytes (end of word) the sorting is
     // done on flags and then on affixID.
     while (node != NULL
-           && (node->wn_byte < word[i]
+           && (node->wn_byte < (uint8_t)word[i]
                || (node->wn_byte == NUL
                    && (flags < 0
                        ? node->wn_affixID < (unsigned)affixID
@@ -4035,18 +3915,18 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
       node = *prev;
     }
     if (node == NULL
-        || node->wn_byte != word[i]
+        || node->wn_byte != (uint8_t)word[i]
         || (word[i] == NUL
             && (flags < 0
                 || spin->si_sugtree
                 || node->wn_flags != (flags & WN_MASK)
                 || node->wn_affixID != affixID))) {
       // Allocate a new node.
-      np = get_wordnode(spin);
+      wordnode_T *np = get_wordnode(spin);
       if (np == NULL) {
         return FAIL;
       }
-      np->wn_byte = word[i];
+      np->wn_byte = (uint8_t)word[i];
 
       // If "node" is NULL this is a new child or the end of the sibling
       // list: ref count is one.  Otherwise use ref count of sibling and
@@ -4068,14 +3948,14 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root
     if (word[i] == NUL) {
       node->wn_flags = (uint16_t)flags;
       node->wn_region |= (int16_t)region;
-      node->wn_affixID = (char_u)affixID;
+      node->wn_affixID = (uint8_t)affixID;
       break;
     }
     prev = &node->wn_child;
     node = *prev;
   }
 #ifdef SPELL_PRINTTREE
-  smsg((char_u *)"Added \"%s\"", word);
+  smsg(0, "Added \"%s\"", word);
   spell_print_tree(root->wn_sibling);
 #endif
 
@@ -4164,11 +4044,10 @@ static wordnode_T *get_wordnode(spellinfo_T *spin)
 static int deref_wordnode(spellinfo_T *spin, wordnode_T *node)
   FUNC_ATTR_NONNULL_ALL
 {
-  wordnode_T *np;
   int cnt = 0;
 
   if (--node->wn_refs == 0) {
-    for (np = node; np != NULL; np = np->wn_sibling) {
+    for (wordnode_T *np = node; np != NULL; np = np->wn_sibling) {
       if (np->wn_child != NULL) {
         cnt += deref_wordnode(spin, np->wn_child);
       }
@@ -4195,7 +4074,7 @@ static void wordtree_compress(spellinfo_T *spin, wordnode_T *root, const char *n
   FUNC_ATTR_NONNULL_ALL
 {
   hashtab_T ht;
-  long tot = 0;
+  int tot = 0;
   long perc;
 
   // Skip the root itself, it's not actually used.  The first sibling is the
@@ -4205,7 +4084,7 @@ static void wordtree_compress(spellinfo_T *spin, wordnode_T *root, const char *n
   }
 
   hash_init(&ht);
-  const long n = node_compress(spin, root->wn_sibling, &ht, &tot);
+  const int n = node_compress(spin, root->wn_sibling, &ht, &tot);
 
 #ifndef SPELL_PRINTTREE
   if (spin->si_verbose || p_verbose > 2)
@@ -4219,7 +4098,7 @@ static void wordtree_compress(spellinfo_T *spin, wordnode_T *root, const char *n
       perc = (tot - n) * 100 / tot;
     }
     vim_snprintf(IObuff, IOSIZE,
-                 _("Compressed %s of %ld nodes; %ld (%ld%%) remaining"),
+                 _("Compressed %s of %d nodes; %d (%ld%%) remaining"),
                  name, tot, tot - n, perc);
     spell_message(spin, IObuff);
   }
@@ -4233,32 +4112,29 @@ static void wordtree_compress(spellinfo_T *spin, wordnode_T *root, const char *n
 /// Returns the number of compressed nodes.
 ///
 /// @param tot  total count of nodes before compressing, incremented while going through the tree
-static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, long *tot)
+static int node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, int *tot)
   FUNC_ATTR_NONNULL_ALL
 {
-  wordnode_T *np;
   wordnode_T *tp;
   wordnode_T *child;
-  hash_T hash;
-  hashitem_T *hi;
-  long len = 0;
-  unsigned nr, n;
-  long compressed = 0;
+  int len = 0;
+  unsigned n;
+  int compressed = 0;
 
   // Go through the list of siblings.  Compress each child and then try
   // finding an identical child to replace it.
   // Note that with "child" we mean not just the node that is pointed to,
   // but the whole list of siblings of which the child node is the first.
-  for (np = node; np != NULL && !got_int; np = np->wn_sibling) {
+  for (wordnode_T *np = node; np != NULL && !got_int; np = np->wn_sibling) {
     len++;
     if ((child = np->wn_child) != NULL) {
       // Compress the child first.  This fills hashkey.
       compressed += node_compress(spin, child, ht, tot);
 
       // Try to find an identical child.
-      hash = hash_hash((char *)child->wn_u1.hashkey);
-      hi = hash_lookup(ht, (const char *)child->wn_u1.hashkey,
-                       strlen((char *)child->wn_u1.hashkey), hash);
+      hash_T hash = hash_hash((char *)child->wn_u1.hashkey);
+      hashitem_T *hi = hash_lookup(ht, (const char *)child->wn_u1.hashkey,
+                                   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
@@ -4294,9 +4170,9 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
   // Make a hash key for the node and its siblings, so that we can quickly
   // find a lookalike node.  This must be done after compressing the sibling
   // list, otherwise the hash key would become invalid by the compression.
-  node->wn_u1.hashkey[0] = (char_u)len;
-  nr = 0;
-  for (np = node; np != NULL; np = np->wn_sibling) {
+  node->wn_u1.hashkey[0] = (uint8_t)len;
+  unsigned nr = 0;
+  for (wordnode_T *np = node; np != NULL; np = np->wn_sibling) {
     if (np->wn_byte == NUL) {
       // end node: use wn_flags, wn_region and wn_affixID
       n = (unsigned)(np->wn_flags + (np->wn_region << 8) + (np->wn_affixID << 16));
@@ -4309,13 +4185,13 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
 
   // Avoid NUL bytes, it terminates the hash key.
   n = nr & 0xff;
-  node->wn_u1.hashkey[1] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[1] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 8) & 0xff;
-  node->wn_u1.hashkey[2] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[2] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 16) & 0xff;
-  node->wn_u1.hashkey[3] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[3] = n == 0 ? 1 : (uint8_t)n;
   n = (nr >> 24) & 0xff;
-  node->wn_u1.hashkey[4] = n == 0 ? 1 : (char_u)n;
+  node->wn_u1.hashkey[4] = n == 0 ? 1 : (uint8_t)n;
   node->wn_u1.hashkey[5] = NUL;
 
   // Check for CTRL-C pressed now and then.
@@ -4371,7 +4247,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
   // <HEADER>: <fileID> <versionnr>
   // <fileID>
   size_t fwv = fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, 1, fd);
-  if (fwv != (size_t)1) {
+  if (fwv != 1) {
     // Catch first write error, don't try writing more.
     goto theend;
   }
@@ -4414,7 +4290,6 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
   // the table (avoids that it conflicts).  File is shorter too.
   if (!spin->si_ascii && !spin->si_add) {
     char folchars[128 * 8];
-    int flags;
 
     putc(SN_CHARFLAGS, fd);                             // <sectionID>
     putc(SNF_REQUIRED, fd);                             // <sectionflags>
@@ -4422,13 +4297,13 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
     // Form the <folchars> string first, we need to know its length.
     size_t l = 0;
     for (size_t i = 128; i < 256; i++) {
-      l += (size_t)utf_char2bytes(spelltab.st_fold[i], (char *)folchars + l);
+      l += (size_t)utf_char2bytes(spelltab.st_fold[i], folchars + l);
     }
     put_bytes(fd, 1 + 128 + 2 + l, 4);                  // <sectionlen>
 
     fputc(128, fd);                                     // <charflagslen>
     for (size_t i = 128; i < 256; i++) {
-      flags = 0;
+      int flags = 0;
       if (spelltab.st_isw[i]) {
         flags |= CF_WORD;
       }
@@ -4471,7 +4346,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
   // round 1: SN_REP section
   // round 2: SN_SAL section (unless SN_SOFO is used)
   // round 3: SN_REPSAL section
-  for (unsigned int round = 1; round <= 3; round++) {
+  for (unsigned round = 1; round <= 3; round++) {
     garray_T *gap;
     if (round == 1) {
       gap = &spin->si_rep;
@@ -4534,7 +4409,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
       // <rep> : <repfromlen> <repfrom> <reptolen> <repto>
       // <sal> : <salfromlen> <salfrom> <saltolen> <salto>
       fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
-      for (unsigned int rr = 1; rr <= 2; rr++) {
+      for (unsigned rr = 1; rr <= 2; rr++) {
         char *p = rr == 1 ? ftp->ft_from : ftp->ft_to;
         l = strlen(p);
         assert(l < INT_MAX);
@@ -4571,7 +4446,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
 
     // round 1: count the bytes
     // round 2: write the bytes
-    for (unsigned int round = 1; round <= 2; round++) {
+    for (unsigned round = 1; round <= 2; round++) {
       size_t todo;
       size_t len = 0;
       hashitem_T *hi;
@@ -4694,7 +4569,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
 
   // <LWORDTREE>  <KWORDTREE>  <PREFIXTREE>
   spin->si_memtot = 0;
-  for (unsigned int round = 1; round <= 3; round++) {
+  for (unsigned round = 1; round <= 3; round++) {
     wordnode_T *tree;
     if (round == 1) {
       tree = spin->si_foldroot->wn_sibling;
@@ -4730,7 +4605,7 @@ theend:
     retval = FAIL;
   }
 
-  if (fwv != (size_t)1) {
+  if (fwv != 1) {
     retval = FAIL;
   }
   if (retval == FAIL) {
@@ -4745,10 +4620,8 @@ theend:
 // space.
 static void clear_node(wordnode_T *node)
 {
-  wordnode_T *np;
-
   if (node != NULL) {
-    for (np = node; np != NULL; np = np->wn_sibling) {
+    for (wordnode_T *np = node; np != NULL; np = np->wn_sibling) {
       np->wn_u1.index = 0;
       np->wn_u2.wnode = NULL;
 
@@ -4906,7 +4779,6 @@ void ex_mkspell(exarg_T *eap)
 static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
 {
   char *fname = NULL;
-  int len;
   slang_T *slang;
   bool free_slang = false;
 
@@ -4953,7 +4825,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
     goto theend;
   }
 
-  smsg(_("Number of words after soundfolding: %" PRId64),
+  smsg(0, _("Number of words after soundfolding: %" PRId64),
        (int64_t)spin->si_spellbuf->b_ml.ml_line_count);
 
   // Compress the soundfold trie.
@@ -4964,7 +4836,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
   // Make the file name by changing ".spl" to ".sug".
   fname = xmalloc(MAXPATHL);
   xstrlcpy(fname, wfname, MAXPATHL);
-  len = (int)strlen(fname);
+  int len = (int)strlen(fname);
   fname[len - 2] = 'u';
   fname[len - 1] = 'g';
   sug_write(spin, fname);
@@ -4981,15 +4853,10 @@ theend:
 // Build the soundfold trie for language "slang".
 static int sug_filltree(spellinfo_T *spin, slang_T *slang)
 {
-  char_u *byts;
-  idx_T *idxs;
-  int depth;
   idx_T arridx[MAXWLEN];
   int curi[MAXWLEN];
-  char_u tword[MAXWLEN];
-  char_u tsalword[MAXWLEN];
-  int c;
-  idx_T n;
+  char tword[MAXWLEN];
+  char tsalword[MAXWLEN];
   unsigned words_done = 0;
   int wordcount[MAXWLEN];
 
@@ -5000,15 +4867,18 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
   spin->si_sugtree = true;
 
   // Go through the whole case-folded tree, soundfold each word and put it
-  // in the trie.
-  byts = (char_u *)slang->sl_fbyts;
-  idxs = slang->sl_fidxs;
+  // in the trie.  Bail out if the tree is empty.
+  uint8_t *byts = slang->sl_fbyts;
+  idx_T *idxs = slang->sl_fidxs;
+  if (byts == NULL || idxs == NULL) {
+    return FAIL;
+  }
 
   arridx[0] = 0;
   curi[0] = 1;
   wordcount[0] = 0;
 
-  depth = 0;
+  int depth = 0;
   while (depth >= 0 && !got_int) {
     if (curi[depth] > byts[arridx[depth]]) {
       // Done all bytes at this node, go up one level.
@@ -5021,14 +4891,14 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
       line_breakcheck();
     } else {
       // Do one more byte at this node.
-      n = arridx[depth] + curi[depth];
+      idx_T n = arridx[depth] + curi[depth];
       curi[depth]++;
 
-      c = byts[n];
+      int c = byts[n];
       if (c == 0) {
         // Sound-fold the word.
         tword[depth] = NUL;
-        spell_soundfold(slang, (char *)tword, true, (char *)tsalword);
+        spell_soundfold(slang, tword, true, tsalword);
 
         // We use the "flags" field for the MSB of the wordnr,
         // "region" for the LSB of the wordnr.
@@ -5053,7 +4923,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
         }
       } else {
         // Normal char, go one level deeper.
-        tword[depth++] = (char_u)c;
+        tword[depth++] = (char)(uint8_t)c;
         arridx[depth] = idxs[n];
         curi[depth] = 1;
         wordcount[depth] = 0;
@@ -5061,7 +4931,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
     }
   }
 
-  smsg(_("Total number of words: %d"), words_done);
+  smsg(0, _("Total number of words: %d"), words_done);
 
   return OK;
 }
@@ -5100,31 +4970,27 @@ static int sug_maketable(spellinfo_T *spin)
 /// @param gap  place to store line of numbers
 static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, garray_T *gap)
 {
-  wordnode_T *p, *np;
   int wordnr = startwordnr;
-  int nr;
-  int prev_nr;
 
-  for (p = node; p != NULL; p = p->wn_sibling) {
+  for (wordnode_T *p = node; p != NULL; p = p->wn_sibling) {
     if (p->wn_byte == NUL) {
       gap->ga_len = 0;
-      prev_nr = 0;
-      for (np = p; np != NULL && np->wn_byte == NUL; np = np->wn_sibling) {
+      int prev_nr = 0;
+      for (wordnode_T *np = p; np != NULL && np->wn_byte == NUL; np = np->wn_sibling) {
         ga_grow(gap, 10);
 
-        nr = (np->wn_flags << 16) + (np->wn_region & 0xffff);
+        int nr = (np->wn_flags << 16) + (np->wn_region & 0xffff);
         // Compute the offset from the previous nr and store the
         // offset in a way that it takes a minimum number of bytes.
         // It's a bit like utf-8, but without the need to mark
         // following bytes.
         nr -= prev_nr;
         prev_nr += nr;
-        gap->ga_len += offset2bytes(nr,
-                                    (char_u *)gap->ga_data + gap->ga_len);
+        gap->ga_len += offset2bytes(nr, (char *)gap->ga_data + gap->ga_len);
       }
 
       // add the NUL byte
-      ((char_u *)gap->ga_data)[gap->ga_len++] = NUL;
+      ((char *)gap->ga_data)[gap->ga_len++] = NUL;
 
       if (ml_append_buf(spin->si_spellbuf, (linenr_T)wordnr,
                         gap->ga_data, gap->ga_len, true) == FAIL) {
@@ -5155,39 +5021,38 @@ static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, g
 // Convert an offset into a minimal number of bytes.
 // Similar to utf_char2byters, but use 8 bits in followup bytes and avoid NUL
 // bytes.
-static int offset2bytes(int nr, char_u *buf)
+static int offset2bytes(int nr, char *buf_in)
 {
-  int rem;
-  int b1, b2, b3, b4;
+  uint8_t *buf = (uint8_t *)buf_in;
 
   // Split the number in parts of base 255.  We need to avoid NUL bytes.
-  b1 = nr % 255 + 1;
-  rem = nr / 255;
-  b2 = rem % 255 + 1;
+  int b1 = nr % 255 + 1;
+  int rem = nr / 255;
+  int b2 = rem % 255 + 1;
   rem = rem / 255;
-  b3 = rem % 255 + 1;
-  b4 = rem / 255 + 1;
+  int b3 = rem % 255 + 1;
+  int b4 = rem / 255 + 1;
 
   if (b4 > 1 || b3 > 0x1f) {    // 4 bytes
-    buf[0] = (char_u)(0xe0 + b4);
-    buf[1] = (char_u)b3;
-    buf[2] = (char_u)b2;
-    buf[3] = (char_u)b1;
+    buf[0] = (uint8_t)(0xe0 + b4);
+    buf[1] = (uint8_t)b3;
+    buf[2] = (uint8_t)b2;
+    buf[3] = (uint8_t)b1;
     return 4;
   }
   if (b3 > 1 || b2 > 0x3f) {   // 3 bytes
-    buf[0] = (char_u)(0xc0 + b3);
-    buf[1] = (char_u)b2;
-    buf[2] = (char_u)b1;
+    buf[0] = (uint8_t)(0xc0 + b3);
+    buf[1] = (uint8_t)b2;
+    buf[2] = (uint8_t)b1;
     return 3;
   }
   if (b2 > 1 || b1 > 0x7f) {   // 2 bytes
-    buf[0] = (char_u)(0x80 + b2);
-    buf[1] = (char_u)b1;
+    buf[0] = (uint8_t)(0x80 + b2);
+    buf[1] = (uint8_t)b1;
     return 2;
   }
   // 1 byte
-  buf[0] = (char_u)b1;
+  buf[0] = (uint8_t)b1;
   return 1;
 }
 
@@ -5206,7 +5071,7 @@ static void sug_write(spellinfo_T *spin, char *fname)
   spell_message(spin, IObuff);
 
   // <SUGHEADER>: <fileID> <versionnr> <timestamp>
-  if (fwrite(VIMSUGMAGIC, VIMSUGMAGICL, (size_t)1, fd) != 1) {  // <fileID>
+  if (fwrite(VIMSUGMAGIC, VIMSUGMAGICL, 1, fd) != 1) {  // <fileID>
     emsg(_(e_write));
     goto theend;
   }
@@ -5242,7 +5107,7 @@ static void sug_write(spellinfo_T *spin, char *fname)
 
   for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
     // <sugline>: <sugnr> ... NUL
-    char *line = ml_get_buf(spin->si_spellbuf, lnum, false);
+    char *line = ml_get_buf(spin->si_spellbuf, lnum);
     size_t len = strlen(line) + 1;
     if (fwrite(line, len, 1, fd) == 0) {
       emsg(_(e_write));
@@ -5278,11 +5143,7 @@ theend:
 static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool added_word)
 {
   char *fname = NULL;
-  char **innames;
-  int incount;
   afffile_T *(afile[MAXREGIONS]);
-  int i;
-  int len;
   bool error = false;
   spellinfo_T spin;
 
@@ -5302,13 +5163,13 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
   // default: fnames[0] is output file, following are input files
   // When "fcount" is 1 there is only one file.
-  innames = &fnames[fcount == 1 ? 0 : 1];
-  incount = fcount - 1;
+  char **innames = &fnames[fcount == 1 ? 0 : 1];
+  int incount = fcount - 1;
 
   char *wfname = xmalloc(MAXPATHL);
 
   if (fcount >= 1) {
-    len = (int)strlen(fnames[0]);
+    int 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".
@@ -5361,18 +5222,18 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
     // Init the aff and dic pointers.
     // Get the region names if there are more than 2 arguments.
-    for (i = 0; i < incount; i++) {
+    for (int i = 0; i < incount; i++) {
       afile[i] = NULL;
 
       if (incount > 1) {
-        len = (int)strlen(innames[i]);
+        int len = (int)strlen(innames[i]);
         if (strlen(path_tail(innames[i])) < 5
             || innames[i][len - 3] != '_') {
           semsg(_("E755: Invalid region in %s"), innames[i]);
           goto theend;
         }
-        spin.si_region_name[i * 2] = (char_u)TOLOWER_ASC(innames[i][len - 2]);
-        spin.si_region_name[i * 2 + 1] = (char_u)TOLOWER_ASC(innames[i][len - 1]);
+        spin.si_region_name[i * 2] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 2]);
+        spin.si_region_name[i * 2 + 1] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 1]);
       }
     }
     spin.si_region_count = incount;
@@ -5393,7 +5254,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
     // Read all the .aff and .dic files.
     // Text is converted to 'encoding'.
     // Words are stored in the case-folded and keep-case trees.
-    for (i = 0; i < incount && !error; i++) {
+    for (int i = 0; i < incount && !error; i++) {
       spin.si_conv.vc_type = CONV_NONE;
       spin.si_region = 1 << i;
 
@@ -5424,7 +5285,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
     }
 
     if (spin.si_compflags != NULL && spin.si_nobreak) {
-      msg(_("Warning: both compounding and NOBREAK specified"));
+      msg(_("Warning: both compounding and NOBREAK specified"), 0);
     }
 
     if (!error && !got_int) {
@@ -5464,7 +5325,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
     hash_clear_all(&spin.si_commonwords, 0);
 
     // Free the .aff file structures.
-    for (i = 0; i < incount; i++) {
+    for (int i = 0; i < incount; i++) {
       if (afile[i] != NULL) {
         spell_free_aff(afile[i]);
       }
@@ -5494,7 +5355,7 @@ static void spell_message(const spellinfo_T *spin, char *str)
     if (!spin->si_verbose) {
       verbose_enter();
     }
-    msg(str);
+    msg(str, 0);
     ui_flush();
     if (!spin->si_verbose) {
       verbose_leave();
@@ -5509,8 +5370,9 @@ static void spell_message(const spellinfo_T *spin, char *str)
 void ex_spell(exarg_T *eap)
 {
   spell_add_word(eap->arg, (int)strlen(eap->arg),
-                 eap->cmdidx == CMD_spellwrong ? SPELL_ADD_BAD :
-                 eap->cmdidx == CMD_spellrare ? SPELL_ADD_RARE : SPELL_ADD_GOOD,
+                 eap->cmdidx == CMD_spellwrong
+                 ? SPELL_ADD_BAD
+                 : eap->cmdidx == CMD_spellrare ? SPELL_ADD_RARE : SPELL_ADD_GOOD,
                  eap->forceit ? 0 : (int)eap->line2,
                  eap->cmdidx == CMD_spellundo);
 }
@@ -5528,8 +5390,6 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
   char *fname;
   char *fnamebuf = NULL;
   char line[MAXWLEN * 2];
-  long fpos, fpos_next = 0;
-  int i;
   char *spf;
 
   if (!valid_spell_word(word, word + len)) {
@@ -5546,6 +5406,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
     }
     fname = int_wordlist;
   } else {
+    int i;
     // If 'spellfile' isn't set figure out a good default value.
     if (*curwin->w_s->b_p_spf == NUL) {
       init_spellfile();
@@ -5585,13 +5446,15 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
   }
 
   if (what == SPELL_ADD_BAD || undo) {
+    int fpos_next = 0;
+    int fpos = 0;
     // When the word appears as good word we need to remove that one,
     // since its flags sort before the one with WF_BANNED.
     fd = os_fopen(fname, "r");
     if (fd != NULL) {
-      while (!vim_fgets((char *)line, MAXWLEN * 2, fd)) {
+      while (!vim_fgets(line, MAXWLEN * 2, fd)) {
         fpos = fpos_next;
-        fpos_next = ftell(fd);
+        fpos_next = (int)ftell(fd);
         if (fpos_next < 0) {
           break;  // should never happen
         }
@@ -5609,7 +5472,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
             fputc('#', fd);
             if (undo) {
               home_replace(NULL, fname, NameBuff, MAXPATHL, true);
-              smsg(_("Word '%.*s' removed from %s"), len, word, NameBuff);
+              smsg(0, _("Word '%.*s' removed from %s"), len, word, NameBuff);
             }
           }
           if (fseek(fd, fpos_next, SEEK_SET) != 0) {
@@ -5627,21 +5490,21 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
   if (!undo) {
     fd = os_fopen(fname, "a");
     if (fd == NULL && new_spf) {
-      char_u *p;
+      char *p;
 
       // We just initialized the 'spellfile' option and can't open the
       // file.  We may need to create the "spell" directory first.  We
       // already checked the runtime directory is writable in
       // init_spellfile().
       if (!dir_of_file_exists(fname)
-          && (p = (char_u *)path_tail_with_sep(fname)) != (char_u *)fname) {
-        int c = *p;
+          && (p = path_tail_with_sep(fname)) != fname) {
+        char c = *p;
 
         // The directory doesn't exist.  Try creating it and opening
         // the file again.
         *p = NUL;
         os_mkdir(fname, 0755);
-        *p = (char_u)c;
+        *p = c;
         fd = os_fopen(fname, "a");
       }
     }
@@ -5659,7 +5522,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
       fclose(fd);
 
       home_replace(NULL, fname, NameBuff, MAXPATHL, true);
-      smsg(_("Word '%.*s' added to %s"), len, word, NameBuff);
+      smsg(0, _("Word '%.*s' added to %s"), len, word, NameBuff);
     }
   }
 
@@ -5680,10 +5543,7 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo)
 // Initialize 'spellfile' for the current buffer.
 static void init_spellfile(void)
 {
-  char *buf;
   int l;
-  char *fname;
-  char *rtp;
   char *lend;
   bool aspath = false;
   char *lstart = curbuf->b_s.b_p_spl;
@@ -5692,7 +5552,7 @@ static void init_spellfile(void)
     return;
   }
 
-  buf = xmalloc(MAXPATHL);
+  char *buf = xmalloc(MAXPATHL);
 
   // Find the end of the language name.  Exclude the region.  If there
   // is a path separator remember the start of the tail.
@@ -5706,7 +5566,7 @@ static void init_spellfile(void)
 
   // Loop over all entries in 'runtimepath'.  Use the first one where we
   // are allowed to write.
-  rtp = p_rtp;
+  char *rtp = p_rtp;
   while (*rtp != NUL) {
     if (aspath) {
       // Use directory of an entry with path, e.g., for
@@ -5734,14 +5594,14 @@ static void init_spellfile(void)
                      "/%.*s", (int)(lend - lstart), lstart);
       }
       l = (int)strlen(buf);
-      fname = LANGP_ENTRY(curwin->w_s->b_langp, 0)
-              ->lp_slang->sl_fname;
+      char *fname = LANGP_ENTRY(curwin->w_s->b_langp, 0)
+                    ->lp_slang->sl_fname;
       vim_snprintf(buf + l, MAXPATHL - (size_t)l, ".%s.add",
                    ((fname != NULL
                      && strstr(path_tail(fname), ".ascii.") != NULL)
                     ? "ascii"
-                    : (const char *)spell_enc()));
-      set_option_value_give_err("spellfile", 0L, buf, OPT_LOCAL);
+                    : spell_enc()));
+      set_option_value_give_err("spellfile", CSTR_AS_OPTVAL(buf), OPT_LOCAL);
       break;
     }
     aspath = false;
@@ -5753,28 +5613,27 @@ static void init_spellfile(void)
 /// Set the spell character tables from strings in the .spl file.
 ///
 /// @param cnt  length of "flags"
-static void set_spell_charflags(const char_u *flags, int cnt, char *fol)
+static void set_spell_charflags(const char *flags_in, int cnt, const char *fol)
 {
+  const uint8_t *flags = (uint8_t *)flags_in;
   // We build the new tables here first, so that we can compare with the
   // previous one.
   spelltab_T new_st;
-  int i;
-  char *p = fol;
-  int c;
+  const char *p = fol;
 
   clear_spell_chartab(&new_st);
 
-  for (i = 0; i < 128; i++) {
+  for (int i = 0; i < 128; i++) {
     if (i < cnt) {
       new_st.st_isw[i + 128] = (flags[i] & CF_WORD) != 0;
       new_st.st_isu[i + 128] = (flags[i] & CF_UPPER) != 0;
     }
 
     if (*p != NUL) {
-      c = mb_ptr2char_adv((const char **)&p);
-      new_st.st_fold[i + 128] = (char_u)c;
+      int c = mb_ptr2char_adv(&p);
+      new_st.st_fold[i + 128] = (uint8_t)c;
       if (i + 128 != c && new_st.st_isu[i + 128] && c < 256) {
-        new_st.st_upper[c] = (char_u)(i + 128);
+        new_st.st_upper[c] = (uint8_t)(i + 128);
       }
     }
   }
@@ -5784,11 +5643,9 @@ static void set_spell_charflags(const char_u *flags, int cnt, char *fol)
 
 static int set_spell_finish(spelltab_T *new_st)
 {
-  int i;
-
   if (did_set_spelltab) {
     // check that it's the same table
-    for (i = 0; i < 256; i++) {
+    for (int i = 0; i < 256; i++) {
       if (spelltab.st_isw[i] != new_st->st_isw[i]
           || spelltab.st_isu[i] != new_st->st_isu[i]
           || spelltab.st_fold[i] != new_st->st_fold[i]
@@ -5837,12 +5694,9 @@ static int write_spell_prefcond(FILE *fd, garray_T *gap, size_t *fwv)
 }
 
 // Use map string "map" for languages "lp".
-static void set_map_str(slang_T *lp, char *map)
+static void set_map_str(slang_T *lp, const char *map)
 {
-  char *p;
   int headc = 0;
-  int c;
-  int i;
 
   if (*map == NUL) {
     lp->sl_has_map = false;
@@ -5851,7 +5705,7 @@ static void set_map_str(slang_T *lp, char *map)
   lp->sl_has_map = true;
 
   // Init the array and hash tables empty.
-  for (i = 0; i < 256; i++) {
+  for (int i = 0; i < 256; i++) {
     lp->sl_map_array[i] = 0;
   }
   hash_init(&lp->sl_map_hash);
@@ -5859,8 +5713,8 @@ static void set_map_str(slang_T *lp, char *map)
   // The similar characters are stored separated with slashes:
   // "aaa/bbb/ccc/".  Fill sl_map_array[c] with the character before c and
   // before the same slash.  For characters above 255 sl_map_hash is used.
-  for (p = map; *p != NUL;) {
-    c = mb_cptr2char_adv((const char **)&p);
+  for (const char *p = map; *p != NUL;) {
+    int c = mb_cptr2char_adv(&p);
     if (c == '/') {
       headc = 0;
     } else {
@@ -5883,13 +5737,13 @@ static void set_map_str(slang_T *lp, char *map)
         utf_char2bytes(headc, b + cl + 1);
         b[cl + 1 + headcl] = NUL;
         hash = hash_hash(b);
-        hi = hash_lookup(&lp->sl_map_hash, (const char *)b, strlen(b), hash);
+        hi = hash_lookup(&lp->sl_map_hash, b, strlen(b), hash);
         if (HASHITEM_EMPTY(hi)) {
           hash_add_item(&lp->sl_map_hash, hi, b, hash);
         } else {
           // This should have been checked when generating the .spl
           // file.
-          emsg(_("E783: duplicate char in MAP entry"));
+          emsg(_(e_duplicate_char_in_map_entry));
           xfree(b);
         }
       } else {