refactor: replace char_u variables and functions with char

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

13 files changed, 374 insertions, 379 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 9b21608ce9..b4d4265a37 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -1113,7 +1113,7 @@ void nvim_buf_set_name(Buffer buffer, String name, Error *err)
   // Using aucmd_*: autocommands will be executed by rename_buffer
   aco_save_T aco;
   aucmd_prepbuf(&aco, buf);
-  int ren_ret = rename_buffer((char_u *)name.data);
+  int ren_ret = rename_buffer(name.data);
   aucmd_restbuf(&aco);
 
   if (try_end(err)) {
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 5786a73f43..c70d845c42 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -4870,7 +4870,7 @@ void do_arg_all(int count, int forceit, int keep_tabs)
         new_curwin = curwin;
         new_curtab = curtab;
       }
-      (void)do_ecmd(0, alist_name(&AARGLIST(alist)[i]), NULL, NULL, ECMD_ONE,
+      (void)do_ecmd(0, (char *)alist_name(&AARGLIST(alist)[i]), NULL, NULL, ECMD_ONE,
                     ((buf_hide(curwin->w_buffer)
                       || bufIsChanged(curwin->w_buffer))
                      ? ECMD_HIDE : 0) + ECMD_OLDBUF,
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 7be8bbcaac..5cd3e7f968 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -117,7 +117,7 @@ static int preview_bufnr = 0;
 /// ":ascii" and "ga" implementation
 void do_ascii(const exarg_T *const eap)
 {
-  char_u *dig;
+  char *dig;
   int cc[MAX_MCO];
   int c = utfc_ptr2char(get_cursor_pos_ptr(), cc);
   if (c == NUL) {
@@ -137,8 +137,8 @@ void do_ascii(const exarg_T *const eap)
                       : c);
     char buf1[20];
     if (vim_isprintc_strict(c) && (c < ' ' || c > '~')) {
-      char_u buf3[7];
-      transchar_nonprint(curbuf, buf3, c);
+      char buf3[7];
+      transchar_nonprint(curbuf, (char_u *)buf3, c);
       vim_snprintf(buf1, sizeof(buf1), "  <%s>", (char *)buf3);
     } else {
       buf1[0] = NUL;
@@ -146,7 +146,7 @@ void do_ascii(const exarg_T *const eap)
     char buf2[20];
     buf2[0] = NUL;
 
-    dig = get_digraph_for_char(cval);
+    dig = (char *)get_digraph_for_char(cval);
     if (dig != NULL) {
       iobuff_len += (
                      vim_snprintf((char *)IObuff + iobuff_len,
@@ -196,7 +196,7 @@ void do_ascii(const exarg_T *const eap)
     }
     iobuff_len += utf_char2bytes(c, IObuff + iobuff_len);
 
-    dig = get_digraph_for_char(c);
+    dig = (char *)get_digraph_for_char(c);
     if (dig != NULL) {
       iobuff_len += (
                      vim_snprintf((char *)IObuff + iobuff_len,
@@ -326,31 +326,31 @@ void ex_align(exarg_T *eap)
 /// @return  the length of the current line, excluding trailing white space.
 static int linelen(int *has_tab)
 {
-  char_u *line;
-  char_u *first;
-  char_u *last;
+  char *line;
+  char *first;
+  char *last;
   int save;
   int len;
 
   // Get the line.  If it's empty bail out early (could be the empty string
   // for an unloaded buffer).
-  line = get_cursor_line_ptr();
+  line = (char *)get_cursor_line_ptr();
   if (*line == NUL) {
     return 0;
   }
   // find the first non-blank character
-  first = skipwhite(line);
+  first = (char *)skipwhite((char_u *)line);
 
   // find the character after the last non-blank character
   for (last = first + STRLEN(first);
        last > first && ascii_iswhite(last[-1]); last--) {}
-  save = *last;
+  save = (char_u)(*last);
   *last = NUL;
   // Get line length.
-  len = linetabsize(line);
+  len = linetabsize((char_u *)line);
   // Check for embedded TAB.
   if (has_tab != NULL) {
-    *has_tab = vim_strchr(first, TAB) != NULL;
+    *has_tab = vim_strchr((char_u *)first, TAB) != NULL;
   }
   *last = save;
 
@@ -359,8 +359,8 @@ static int linelen(int *has_tab)
 
 // Buffer for two lines used during sorting.  They are allocated to
 // contain the longest line being sorted.
-static char_u *sortbuf1;
-static char_u *sortbuf2;
+static char *sortbuf1;
+static char *sortbuf2;
 
 static int sort_lc;       ///< sort using locale
 static int sort_ic;       ///< ignore case
@@ -457,10 +457,10 @@ void ex_sort(exarg_T *eap)
   long maxlen = 0;
   size_t count = (size_t)(eap->line2 - eap->line1 + 1);
   size_t i;
-  char_u *p;
-  char_u *s;
-  char_u *s2;
-  char_u c;                             // temporary character storage
+  char *p;
+  char *s;
+  char *s2;
+  char c;                             // temporary character storage
   bool unique = false;
   long deleted;
   colnr_T start_col;
@@ -484,7 +484,7 @@ void ex_sort(exarg_T *eap)
   size_t format_found = 0;
   bool change_occurred = false;   // Buffer contents changed.
 
-  for (p = eap->arg; *p != NUL; ++p) {
+  for (p = (char *)eap->arg; *p != NUL; p++) {
     if (ascii_iswhite(*p)) {
       // Skip
     } else if (*p == 'i') {
@@ -513,11 +513,11 @@ void ex_sort(exarg_T *eap)
     } else if (*p == '"') {
       // comment start
       break;
-    } else if (check_nextcmd(p) != NULL) {
-      eap->nextcmd = check_nextcmd(p);
+    } else if (check_nextcmd((char_u *)p) != NULL) {
+      eap->nextcmd = check_nextcmd((char_u *)p);
       break;
     } else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL) {
-      s = skip_regexp(p + 1, *p, true, NULL);
+      s = (char *)skip_regexp((char_u *)p + 1, *p, true, NULL);
       if (*s != *p) {
         emsg(_(e_invalpat));
         goto sortend;
@@ -531,7 +531,7 @@ void ex_sort(exarg_T *eap)
         }
         regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC);
       } else {
-        regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC);
+        regmatch.regprog = vim_regcomp((char_u *)p + 1, RE_MAGIC);
       }
       if (regmatch.regprog == NULL) {
         goto sortend;
@@ -560,8 +560,8 @@ void ex_sort(exarg_T *eap)
   // numbers sorting it's the number to sort on.  This means the pattern
   // matching and number conversion only has to be done once per line.
   // Also get the longest line length for allocating "sortbuf".
-  for (lnum = eap->line1; lnum <= eap->line2; ++lnum) {
-    s = ml_get(lnum);
+  for (lnum = eap->line1; lnum <= eap->line2; lnum++) {
+    s = (char *)ml_get(lnum);
     len = (int)STRLEN(s);
     if (maxlen < len) {
       maxlen = len;
@@ -569,12 +569,12 @@ void ex_sort(exarg_T *eap)
 
     start_col = 0;
     end_col = len;
-    if (regmatch.regprog != NULL && vim_regexec(&regmatch, s, 0)) {
+    if (regmatch.regprog != NULL && vim_regexec(&regmatch, (char_u *)s, 0)) {
       if (sort_rx) {
-        start_col = (colnr_T)(regmatch.startp[0] - s);
-        end_col = (colnr_T)(regmatch.endp[0] - s);
+        start_col = (colnr_T)(regmatch.startp[0] - (char_u *)s);
+        end_col = (colnr_T)(regmatch.endp[0] - (char_u *)s);
       } else {
-        start_col = (colnr_T)(regmatch.endp[0] - s);
+        start_col = (colnr_T)(regmatch.endp[0] - (char_u *)s);
       }
     } else if (regmatch.regprog != NULL) {
       end_col = 0;
@@ -590,11 +590,11 @@ void ex_sort(exarg_T *eap)
       p = s + start_col;
       if (sort_nr) {
         if (sort_what & STR2NR_HEX) {
-          s = skiptohex(p);
+          s = (char *)skiptohex((char_u *)p);
         } else if (sort_what & STR2NR_BIN) {
-          s = (char_u *)skiptobin((char *)p);
+          s = (char *)skiptobin(p);
         } else {
-          s = skiptodigit(p);
+          s = (char *)skiptodigit((char_u *)p);
         }
         if (s > p && s[-1] == '-') {
           s--;  // include preceding negative sign
@@ -605,20 +605,20 @@ void ex_sort(exarg_T *eap)
           nrs[lnum - eap->line1].st_u.num.value = 0;
         } else {
           nrs[lnum - eap->line1].st_u.num.is_number = true;
-          vim_str2nr(s, NULL, NULL, sort_what,
+          vim_str2nr((char_u *)s, NULL, NULL, sort_what,
                      &nrs[lnum - eap->line1].st_u.num.value, NULL, 0, false);
         }
       } else {
-        s = skipwhite(p);
+        s = (char *)skipwhite((char_u *)p);
         if (*s == '+') {
-          s = skipwhite(s + 1);
+          s = (char *)skipwhite((char_u *)s + 1);
         }
 
         if (*s == NUL) {
           // empty line should sort before any number
           nrs[lnum - eap->line1].st_u.value_flt = -DBL_MAX;
         } else {
-          nrs[lnum - eap->line1].st_u.value_flt = strtod((char *)s, NULL);
+          nrs[lnum - eap->line1].st_u.value_flt = strtod(s, NULL);
         }
       }
       *s2 = c;
@@ -662,14 +662,14 @@ void ex_sort(exarg_T *eap)
       change_occurred = true;
     }
 
-    s = ml_get(get_lnum);
+    s = (char *)ml_get(get_lnum);
     size_t bytelen = STRLEN(s) + 1;  // include EOL in bytelen
     old_count += bytelen;
     if (!unique || i == 0 || string_compare(s, sortbuf1) != 0) {
       // Copy the line into a buffer, it may become invalid in
       // ml_append(). And it's needed for "unique".
       STRCPY(sortbuf1, s);
-      if (ml_append(lnum++, sortbuf1, (colnr_T)0, false) == FAIL) {
+      if (ml_append(lnum++, (char_u *)sortbuf1, (colnr_T)0, false) == FAIL) {
         break;
       }
       new_count += bytelen;
@@ -733,11 +733,11 @@ void ex_retab(exarg_T *eap)
   long start_col = 0;                   // For start of white-space string
   long start_vcol = 0;                  // For start of white-space string
   long old_len;
-  char_u *ptr;
-  char_u *new_line = (char_u *)1;  // init to non-NULL
+  char *ptr;
+  char *new_line = (char *)1;  // init to non-NULL
   bool did_undo;                         // called u_save for current line
   long *new_vts_array = NULL;
-  char_u *new_ts_str;  // string value of tab argument
+  char *new_ts_str;  // string value of tab argument
 
   int save_list;
   linenr_T first_line = 0;              // first changed line
@@ -746,7 +746,7 @@ void ex_retab(exarg_T *eap)
   save_list = curwin->w_p_list;
   curwin->w_p_list = 0;             // don't want list mode here
 
-  new_ts_str = eap->arg;
+  new_ts_str = (char *)eap->arg;
   if (!tabstop_set(eap->arg, &new_vts_array)) {
     return;
   }
@@ -761,10 +761,10 @@ void ex_retab(exarg_T *eap)
     new_vts_array = curbuf->b_p_vts_array;
     new_ts_str = NULL;
   } else {
-    new_ts_str = vim_strnsave(new_ts_str, eap->arg - new_ts_str);
+    new_ts_str = xstrnsave(new_ts_str, eap->arg - (char_u *)new_ts_str);
   }
   for (lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) {
-    ptr = ml_get(lnum);
+    ptr = (char *)ml_get(lnum);
     col = 0;
     vcol = 0;
     did_undo = false;
@@ -825,9 +825,9 @@ void ex_retab(exarg_T *eap)
             for (col = 0; col < len; col++) {
               ptr[col] = (col < num_tabs) ? '\t' : ' ';
             }
-            if (ml_replace(lnum, new_line, false) == OK) {
+            if (ml_replace(lnum, (char_u *)new_line, false) == OK) {
               // "new_line" may have been copied
-              new_line = curbuf->b_ml.ml_line_ptr;
+              new_line = (char *)curbuf->b_ml.ml_line_ptr;
               extmark_splice_cols(curbuf, lnum - 1, 0, (colnr_T)old_len,
                                   (colnr_T)new_len - 1, kExtmarkUndo);
             }
@@ -845,12 +845,12 @@ void ex_retab(exarg_T *eap)
       if (ptr[col] == NUL) {
         break;
       }
-      vcol += win_chartabsize(curwin, ptr + col, (colnr_T)vcol);
+      vcol += win_chartabsize(curwin, (char_u *)ptr + col, (colnr_T)vcol);
       if (vcol >= MAXCOL) {
         emsg(_(e_resulting_text_too_long));
         break;
       }
-      col += utfc_ptr2len(ptr + col);
+      col += utfc_ptr2len((char_u *)ptr + col);
     }
     if (new_line == NULL) {                 // out of memory
       break;
@@ -885,7 +885,7 @@ void ex_retab(exarg_T *eap)
     long *old_vts_ary = curbuf->b_p_vts_array;
 
     if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1) {
-      set_string_option_direct("vts", -1, new_ts_str,
+      set_string_option_direct("vts", -1, (char_u *)new_ts_str,
                                OPT_FREE | OPT_LOCAL, 0);
       curbuf->b_p_vts_array = new_vts_array;
       xfree(old_vts_ary);
@@ -907,7 +907,7 @@ void ex_retab(exarg_T *eap)
 /// @return  FAIL for failure, OK otherwise
 int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 {
-  char_u *str;
+  char *str;
   linenr_T l;
   linenr_T extra;      // Num lines added before line1
   linenr_T num_lines;  // Num lines moved
@@ -946,8 +946,8 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     return FAIL;
   }
   for (extra = 0, l = line1; l <= line2; l++) {
-    str = vim_strsave(ml_get(l + extra));
-    ml_append(dest + l - line1, str, (colnr_T)0, false);
+    str = (char *)vim_strsave(ml_get(l + extra));
+    ml_append(dest + l - line1, (char_u *)str, (colnr_T)0, false);
     xfree(str);
     if (dest < line1) {
       extra++;
@@ -1059,7 +1059,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
 {
   linenr_T count;
-  char_u *p;
+  char *p;
 
   count = line2 - line1 + 1;
   if (!cmdmod.lockmarks) {
@@ -1087,8 +1087,8 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
   while (line1 <= line2) {
     // need to use vim_strsave() because the line will be unlocked within
     // ml_append()
-    p = vim_strsave(ml_get(line1));
-    ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, false);
+    p = (char *)vim_strsave(ml_get(line1));
+    ml_append(curwin->w_cursor.lnum, (char_u *)p, (colnr_T)0, false);
     xfree(p);
 
     // situation 2: skip already copied lines
@@ -1113,7 +1113,7 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
   msgmore((long)count);
 }
 
-static char_u *prevcmd = NULL;        // the previous command
+static char *prevcmd = NULL;        // the previous command
 
 #if defined(EXITFREE)
 void free_prev_shellcmd(void)
@@ -1129,14 +1129,14 @@ void free_prev_shellcmd(void)
 void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out)
   FUNC_ATTR_NONNULL_ALL
 {
-  char_u *arg = eap->arg;             // command
+  char *arg = (char *)eap->arg;             // command
   linenr_T line1 = eap->line1;        // start of range
   linenr_T line2 = eap->line2;        // end of range
-  char_u *newcmd = NULL;              // the new command
+  char *newcmd = NULL;              // the new command
   bool free_newcmd = false;           // need to free() newcmd
-  char_u *t;
-  char_u *p;
-  char_u *trailarg;
+  char *t;
+  char *p;
+  char *trailarg;
   int len;
   int scroll_save = msg_scroll;
 
@@ -1213,9 +1213,9 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
     // If % or # appears in the command, it must have been escaped.
     // Reescape them, so that redoing them does not substitute them by the
     // buffername.
-    char_u *cmd = vim_strsave_escaped(prevcmd, (char_u *)"%#");
+    char *cmd = (char *)vim_strsave_escaped((char_u *)prevcmd, (char_u *)"%#");
 
-    AppendToRedobuffLit(cmd, -1);
+    AppendToRedobuffLit((char_u *)cmd, -1);
     xfree(cmd);
     AppendToRedobuff("\n");
     bangredo = false;
@@ -1235,7 +1235,7 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
     msg_start();
     msg_putchar(':');
     msg_putchar('!');
-    msg_outtrans(newcmd);
+    msg_outtrans((char_u *)newcmd);
     msg_clr_eos();
     ui_cursor_goto(msg_row, msg_col);
 
@@ -1266,15 +1266,15 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
 /// We use output redirection if do_out is true.
 ///
 /// @param eap  for forced 'ff' and 'fenc'
-static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd, bool do_in,
+static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, bool do_in,
                       bool do_out)
 {
-  char_u *itmp = NULL;
-  char_u *otmp = NULL;
+  char *itmp = NULL;
+  char *otmp = NULL;
   linenr_T linecount;
   linenr_T read_linecount;
   pos_T cursor_save;
-  char_u *cmd_buf;
+  char *cmd_buf;
   buf_T *old_curbuf = curbuf;
   int shell_flags = 0;
   const pos_T orig_start = curbuf->b_op_start;
@@ -1330,8 +1330,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd,
     curbuf->b_op_start.lnum = line1;
     curbuf->b_op_end.lnum = line2;
     curwin->w_cursor.lnum = line2;
-  } else if ((do_in && (itmp = vim_tempname()) == NULL)
-             || (do_out && (otmp = vim_tempname()) == NULL)) {
+  } else if ((do_in && (itmp = (char *)vim_tempname()) == NULL)
+             || (do_out && (otmp = (char *)vim_tempname()) == NULL)) {
     emsg(_(e_notmp));
     goto filterend;
   }
@@ -1340,8 +1340,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd,
    * The writing and reading of temp files will not be shown.
    * Vi also doesn't do this and the messages are not very informative.
    */
-  ++no_wait_return;             // don't call wait_return() while busy
-  if (itmp != NULL && buf_write(curbuf, itmp, NULL, line1, line2, eap,
+  no_wait_return++;             // don't call wait_return() while busy
+  if (itmp != NULL && buf_write(curbuf, (char_u *)itmp, NULL, line1, line2, eap,
                                 false, false, false, true) == FAIL) {
     msg_putchar('\n');  // Keep message from buf_write().
     no_wait_return--;
@@ -1372,7 +1372,7 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd,
   read_linecount = curbuf->b_ml.ml_line_count;
 
   // Pass on the kShellOptDoOut flag when the output is being redirected.
-  call_shell(cmd_buf, kShellOptFilter | shell_flags, NULL);
+  call_shell((char_u *)cmd_buf, kShellOptFilter | shell_flags, NULL);
   xfree(cmd_buf);
 
   did_check_timestamps = FALSE;
@@ -1386,7 +1386,7 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd,
 
   if (do_out) {
     if (otmp != NULL) {
-      if (readfile(otmp, NULL, line2, (linenr_T)0, (linenr_T)MAXLNUM, eap,
+      if (readfile((char_u *)otmp, NULL, line2, (linenr_T)0, (linenr_T)MAXLNUM, eap,
                    READ_FILTER, false) != OK) {
         if (!aborting()) {
           msg_putchar('\n');
@@ -1479,10 +1479,10 @@ filterend:
   }
 
   if (itmp != NULL) {
-    os_remove((char *)itmp);
+    os_remove(itmp);
   }
   if (otmp != NULL) {
-    os_remove((char *)otmp);
+    os_remove(otmp);
   }
   xfree(itmp);
   xfree(otmp);
@@ -1492,7 +1492,7 @@ filterend:
 /// When "cmd" is NULL start an interactive shell.
 ///
 /// @param flags  may be SHELL_DOOUT when output is redirected
-void do_shell(char_u *cmd, int flags)
+void do_shell(char *cmd, int flags)
 {
   // Disallow shell commands from .exrc and .vimrc in current directory for
   // security reasons.
@@ -1524,7 +1524,7 @@ void do_shell(char_u *cmd, int flags)
   // This ui_cursor_goto is required for when the '\n' resulted in a "delete line
   // 1" command to the terminal.
   ui_cursor_goto(msg_row, msg_col);
-  (void)call_shell(cmd, flags, NULL);
+  (void)call_shell((char_u *)cmd, flags, NULL);
   msg_didout = true;
   did_check_timestamps = false;
   need_check_timestamps = true;
@@ -1563,7 +1563,7 @@ static char *find_pipe(const char *cmd)
 /// @param itmp NULL or the input file.
 /// @param otmp NULL or the output file.
 /// @returns an allocated string with the shell command.
-char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
+char *make_filter_cmd(char *cmd, char *itmp, char *otmp)
 {
   bool is_fish_shell =
 #if defined(UNIX)
@@ -1591,9 +1591,9 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
   if (itmp != NULL || otmp != NULL) {
     char *fmt = is_fish_shell ? "begin; %s; end"
                               :       "(%s)";
-    vim_snprintf(buf, len, fmt, (char *)cmd);
+    vim_snprintf(buf, len, fmt, cmd);
   } else {
-    xstrlcpy(buf, (char *)cmd, len);
+    xstrlcpy(buf, cmd, len);
   }
 
   if (itmp != NULL) {
@@ -1626,9 +1626,9 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
   }
 #endif
   if (otmp != NULL) {
-    append_redir(buf, len, (char *)p_srr, (char *)otmp);
+    append_redir(buf, len, (char *)p_srr, otmp);
   }
-  return (char_u *)buf;
+  return buf;
 }
 
 /// Append output redirection for the given file to the end of the buffer
@@ -1695,9 +1695,9 @@ void print_line(linenr_T lnum, int use_number, int list)
   info_message = false;
 }
 
-int rename_buffer(char_u *new_fname)
+int rename_buffer(char *new_fname)
 {
-  char_u *fname, *sfname, *xfname;
+  char *fname, *sfname, *xfname;
   buf_T *buf;
 
   buf = curbuf;
@@ -1716,19 +1716,19 @@ int rename_buffer(char_u *new_fname)
    * But don't set the alternate file name if the buffer didn't have a
    * name.
    */
-  fname = curbuf->b_ffname;
-  sfname = curbuf->b_sfname;
-  xfname = curbuf->b_fname;
+  fname = (char *)curbuf->b_ffname;
+  sfname = (char *)curbuf->b_sfname;
+  xfname = (char *)curbuf->b_fname;
   curbuf->b_ffname = NULL;
   curbuf->b_sfname = NULL;
-  if (setfname(curbuf, new_fname, NULL, true) == FAIL) {
-    curbuf->b_ffname = fname;
-    curbuf->b_sfname = sfname;
+  if (setfname(curbuf, (char_u *)new_fname, NULL, true) == FAIL) {
+    curbuf->b_ffname = (char_u *)fname;
+    curbuf->b_sfname = (char_u *)sfname;
     return FAIL;
   }
   curbuf->b_flags |= BF_NOTEDITED;
   if (xfname != NULL && *xfname != NUL) {
-    buf = buflist_new(fname, xfname, curwin->w_cursor.lnum, 0);
+    buf = buflist_new((char_u *)fname, (char_u *)xfname, curwin->w_cursor.lnum, 0);
     if (buf != NULL && !cmdmod.keepalt) {
       curwin->w_alt_fnum = buf->b_fnum;
     }
@@ -1755,7 +1755,7 @@ void ex_file(exarg_T *eap)
   }
 
   if (*eap->arg != NUL || eap->addr_count == 1) {
-    if (rename_buffer(eap->arg) == FAIL) {
+    if (rename_buffer((char *)eap->arg) == FAIL) {
       return;
     }
     redraw_tabline = true;
@@ -1800,10 +1800,10 @@ void ex_write(exarg_T *eap)
 int do_write(exarg_T *eap)
 {
   int other;
-  char_u *fname = NULL;            // init to shut up gcc
-  char_u *ffname;
+  char *fname = NULL;            // init to shut up gcc
+  char *ffname;
   int retval = FAIL;
-  char_u *free_fname = NULL;
+  char *free_fname = NULL;
   buf_T *alt_buf = NULL;
   int name_was_missing;
 
@@ -1811,7 +1811,7 @@ int do_write(exarg_T *eap)
     return FAIL;
   }
 
-  ffname = eap->arg;
+  ffname = (char *)eap->arg;
   if (*ffname == NUL) {
     if (eap->cmdidx == CMD_saveas) {
       emsg(_(e_argreq));
@@ -1820,15 +1820,13 @@ int do_write(exarg_T *eap)
     other = FALSE;
   } else {
     fname = ffname;
-    free_fname = (char_u *)fix_fname((char *)ffname);
-    /*
-     * When out-of-memory, keep unexpanded file name, because we MUST be
-     * able to write the file in this situation.
-     */
+    free_fname = fix_fname(ffname);
+    // When out-of-memory, keep unexpanded file name, because we MUST be
+    // able to write the file in this situation.
     if (free_fname != NULL) {
       ffname = free_fname;
     }
-    other = otherfile(ffname);
+    other = otherfile((char_u *)ffname);
   }
 
   /*
@@ -1837,9 +1835,9 @@ int do_write(exarg_T *eap)
   if (other) {
     if (vim_strchr(p_cpo, CPO_ALTWRITE) != NULL
         || eap->cmdidx == CMD_saveas) {
-      alt_buf = setaltfname(ffname, fname, (linenr_T)1);
+      alt_buf = setaltfname((char_u *)ffname, (char_u *)fname, (linenr_T)1);
     } else {
-      alt_buf = buflist_findname(ffname);
+      alt_buf = buflist_findname((char_u *)ffname);
     }
     if (alt_buf != NULL && alt_buf->b_ml.ml_mfp != NULL) {
       // Overwriting a file that is loaded in another buffer is not a
@@ -1859,11 +1857,9 @@ int do_write(exarg_T *eap)
   }
 
   if (!other) {
-    ffname = curbuf->b_ffname;
-    fname = curbuf->b_fname;
-    /*
-     * Not writing the whole file is only allowed with '!'.
-     */
+    ffname = (char *)curbuf->b_ffname;
+    fname = (char *)curbuf->b_fname;
+    // Not writing the whole file is only allowed with '!'.
     if ((eap->line1 != 1
          || eap->line2 != curbuf->b_ml.ml_line_count)
         && !eap->forceit
@@ -1898,15 +1894,15 @@ int do_write(exarg_T *eap)
       // under the new name.  Must be done before buf_write(), because
       // if there is no file name and 'cpo' contains 'F', it will set
       // the file name.
-      fname = alt_buf->b_fname;
+      fname = (char *)alt_buf->b_fname;
       alt_buf->b_fname = curbuf->b_fname;
-      curbuf->b_fname = fname;
-      fname = alt_buf->b_ffname;
+      curbuf->b_fname = (char_u *)fname;
+      fname = (char *)alt_buf->b_ffname;
       alt_buf->b_ffname = curbuf->b_ffname;
-      curbuf->b_ffname = fname;
-      fname = alt_buf->b_sfname;
+      curbuf->b_ffname = (char_u *)fname;
+      fname = (char *)alt_buf->b_sfname;
       alt_buf->b_sfname = curbuf->b_sfname;
-      curbuf->b_sfname = fname;
+      curbuf->b_sfname = (char_u *)fname;
       buf_name_changed(curbuf);
       apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, curbuf);
       apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, alt_buf);
@@ -1930,12 +1926,12 @@ int do_write(exarg_T *eap)
 
       // Autocommands may have changed buffer names, esp. when
       // 'autochdir' is set.
-      fname = curbuf->b_sfname;
+      fname = (char *)curbuf->b_sfname;
     }
 
     name_was_missing = curbuf->b_ffname == NULL;
-    retval = buf_write(curbuf, ffname, fname, eap->line1, eap->line2,
-                       eap, eap->append, eap->forceit, TRUE, FALSE);
+    retval = buf_write(curbuf, (char_u *)ffname, (char_u *)fname, eap->line1, eap->line2,
+                       eap, eap->append, eap->forceit, true, false);
 
     // After ":saveas fname" reset 'readonly'.
     if (eap->cmdidx == CMD_saveas) {
@@ -1966,7 +1962,7 @@ theend:
 /// @param other   writing under other name
 ///
 /// @return  OK if it's OK, FAIL if it is not.
-int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int other)
+int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int other)
 {
   /*
    * write to other file or b_flags set or not writing the whole file:
@@ -1979,20 +1975,20 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int
        || (buf->b_flags & BF_READERR))
       && !p_wa
       && !bt_nofile(buf)
-      && os_path_exists(ffname)) {
+      && os_path_exists((char_u *)ffname)) {
     if (!eap->forceit && !eap->append) {
 #ifdef UNIX
       // It is possible to open a directory on Unix.
-      if (os_isdir(ffname)) {
+      if (os_isdir((char_u *)ffname)) {
         semsg(_(e_isadir2), ffname);
         return FAIL;
       }
 #endif
       if (p_confirm || cmdmod.confirm) {
-        char_u buff[DIALOG_MSG_SIZE];
+        char buff[DIALOG_MSG_SIZE];
 
-        dialog_msg((char *)buff, _("Overwrite existing file \"%s\"?"), (char *)fname);
-        if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) != VIM_YES) {
+        dialog_msg((char *)buff, _("Overwrite existing file \"%s\"?"), fname);
+        if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) != VIM_YES) {
           return FAIL;
         }
         eap->forceit = TRUE;
@@ -2004,9 +2000,9 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int
 
     // For ":w! filename" check that no swap file exists for "filename".
     if (other && !emsg_silent) {
-      char_u *dir;
-      char_u *p;
-      char_u *swapname;
+      char *dir;
+      char *p;
+      char *swapname;
 
       // We only try the first entry in 'directory', without checking if
       // it's writable.  If the "." directory is not writable the write
@@ -2018,19 +2014,19 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int
         STRCPY(dir, ".");
       } else {
         dir = xmalloc(MAXPATHL);
-        p = p_dir;
-        copy_option_part(&p, dir, MAXPATHL, ",");
+        p = (char *)p_dir;
+        copy_option_part((char_u **)&p, (char_u *)dir, MAXPATHL, ",");
       }
-      swapname = makeswapname(fname, ffname, curbuf, dir);
+      swapname = (char *)makeswapname((char_u *)fname, (char_u *)ffname, curbuf, (char_u *)dir);
       xfree(dir);
-      if (os_path_exists(swapname)) {
+      if (os_path_exists((char_u *)swapname)) {
         if (p_confirm || cmdmod.confirm) {
-          char_u buff[DIALOG_MSG_SIZE];
+          char buff[DIALOG_MSG_SIZE];
 
           dialog_msg((char *)buff,
                      _("Swap file \"%s\" exists, overwrite anyway?"),
-                     (char *)swapname);
-          if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2)
+                     swapname);
+          if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2)
               != VIM_YES) {
             xfree(swapname);
             return FAIL;
@@ -2100,9 +2096,9 @@ void do_wqall(exarg_T *eap)
       semsg(_("E141: No file name for buffer %" PRId64), (int64_t)buf->b_fnum);
       error++;
     } else if (check_readonly(&eap->forceit, buf)
-               || check_overwrite(eap, buf, buf->b_fname, buf->b_ffname,
-                                  FALSE) == FAIL) {
-      ++error;
+               || check_overwrite(eap, buf, (char *)buf->b_fname, (char *)buf->b_ffname,
+                                  false) == FAIL) {
+      error++;
     } else {
       bufref_T bufref;
       set_bufref(&bufref, buf);
@@ -2147,7 +2143,7 @@ static int check_readonly(int *forceit, buf_T *buf)
                     || (os_path_exists(buf->b_ffname)
                         && !os_file_is_writable((char *)buf->b_ffname)))) {
     if ((p_confirm || cmdmod.confirm) && buf->b_fname != NULL) {
-      char_u buff[DIALOG_MSG_SIZE];
+      char buff[DIALOG_MSG_SIZE];
 
       if (buf->b_p_ro) {
         dialog_msg((char *)buff,
@@ -2160,7 +2156,7 @@ static int check_readonly(int *forceit, buf_T *buf)
                    (char *)buf->b_fname);
       }
 
-      if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES) {
+      if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) == VIM_YES) {
         // Set forceit, to force the writing of a readonly file
         *forceit = TRUE;
         return FALSE;
@@ -2189,13 +2185,13 @@ static int check_readonly(int *forceit, buf_T *buf)
 ///           GETFILE_NOT_WRITTEN for "not written" error,
 ///           GETFILE_SAME_FILE for success
 ///           GETFILE_OPEN_OTHER for successfully opening another file.
-int getfile(int fnum, char_u *ffname_arg, char_u *sfname_arg, int setpm, linenr_T lnum, int forceit)
+int getfile(int fnum, char *ffname_arg, char *sfname_arg, int setpm, linenr_T lnum, int forceit)
 {
-  char_u *ffname = ffname_arg;
-  char_u *sfname = sfname_arg;
+  char *ffname = ffname_arg;
+  char *sfname = sfname_arg;
   int other;
   int retval;
-  char_u *free_me = NULL;
+  char *free_me = NULL;
 
   if (text_locked()) {
     return GETFILE_ERROR;
@@ -2206,8 +2202,8 @@ int getfile(int fnum, char_u *ffname_arg, char_u *sfname_arg, int setpm, linenr_
 
   if (fnum == 0) {
     // make ffname full path, set sfname
-    fname_expand(curbuf, &ffname, &sfname);
-    other = otherfile(ffname);
+    fname_expand(curbuf, (char_u **)&ffname, (char_u **)&sfname);
+    other = otherfile((char_u *)ffname);
     free_me = ffname;                   // has been allocated, free() later
   } else {
     other = (fnum != curbuf->b_fnum);
@@ -2284,19 +2280,19 @@ theend:
 ///                 info of the previous buffer for "oldwin" is stored.
 ///
 /// @return FAIL for failure, OK otherwise
-int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T newlnum, int flags,
+int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum, int flags,
             win_T *oldwin)
 {
   bool other_file;                      // true if editing another file
   int oldbuf;                           // TRUE if using existing buffer
   bool auto_buf = false;                // true if autocommands brought us
                                         // into the buffer unexpectedly
-  char_u *new_name = NULL;
+  char *new_name = NULL;
   bool did_set_swapcommand = false;
   buf_T *buf;
   bufref_T bufref;
   bufref_T old_curbuf;
-  char_u *free_fname = NULL;
+  char *free_fname = NULL;
   int retval = FAIL;
   long n;
   pos_T orig_pos;
@@ -2304,14 +2300,14 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
   int newcol = -1;
   int solcol = -1;
   pos_T *pos;
-  char_u *command = NULL;
+  char *command = NULL;
   bool did_get_winopts = false;
   int readfile_flags = 0;
   bool did_inc_redrawing_disabled = false;
   long *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so;
 
   if (eap != NULL) {
-    command = eap->do_ecmd_cmd;
+    command = (char *)eap->do_ecmd_cmd;
   }
 
   set_bufref(&old_curbuf, curbuf);
@@ -2328,7 +2324,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
     }
 #ifdef USE_FNAME_CASE
     if (sfname != NULL) {
-      path_fix_case(sfname);             // set correct case for sfname
+      path_fix_case((char_u *)sfname);             // set correct case for sfname
     }
 #endif
 
@@ -2343,14 +2339,14 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
       other_file = false;
     } else {
       if (*ffname == NUL) {                 // re-edit with same file name
-        ffname = curbuf->b_ffname;
-        sfname = curbuf->b_fname;
+        ffname = (char *)curbuf->b_ffname;
+        sfname = (char *)curbuf->b_fname;
       }
-      free_fname = (char_u *)fix_fname((char *)ffname);       // may expand to full path name
+      free_fname = fix_fname(ffname);       // may expand to full path name
       if (free_fname != NULL) {
         ffname = free_fname;
       }
-      other_file = otherfile(ffname);
+      other_file = otherfile((char_u *)ffname);
     }
   }
 
@@ -2373,7 +2369,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
                        | ((flags & ECMD_FORCEIT) ? CCGD_FORCEIT : 0)
                        | (eap == NULL ? 0 : CCGD_EXCMD))) {
     if (fnum == 0 && other_file && ffname != NULL) {
-      (void)setaltfname(ffname, sfname, newlnum < 0 ? 0 : newlnum);
+      (void)setaltfname((char_u *)ffname, (char_u *)sfname, newlnum < 0 ? 0 : newlnum);
     }
     goto theend;
   }
@@ -2422,7 +2418,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
         linenr_T tlnum = 0;
 
         if (command != NULL) {
-          tlnum = atol((char *)command);
+          tlnum = atol(command);
           if (tlnum <= 0) {
             tlnum = 1L;
           }
@@ -2430,13 +2426,13 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
         // Add BLN_NOCURWIN to avoid a new wininfo items are associated
         // with the current window.
         const buf_T *const newbuf
-          = buflist_new(ffname, sfname, tlnum, BLN_LISTED | BLN_NOCURWIN);
+          = buflist_new((char_u *)ffname, (char_u *)sfname, tlnum, BLN_LISTED | BLN_NOCURWIN);
         if (newbuf != NULL && (flags & ECMD_ALTBUF)) {
           curwin->w_alt_fnum = newbuf->b_fnum;
         }
         goto theend;
       }
-      buf = buflist_new(ffname, sfname, 0L,
+      buf = buflist_new((char_u *)ffname, (char_u *)sfname, 0L,
                         BLN_CURBUF | (flags & ECMD_SET_HELP ? 0 : BLN_LISTED));
       // Autocmds may change curwin and curbuf.
       if (oldwin != NULL) {
@@ -2495,7 +2491,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
       // - If we ended up in the new buffer already, need to skip a few
       //         things, set auto_buf.
       if (buf->b_fname != NULL) {
-        new_name = vim_strsave(buf->b_fname);
+        new_name = (char *)vim_strsave(buf->b_fname);
       }
       const bufref_T save_au_new_curbuf = au_new_curbuf;
       set_bufref(&au_new_curbuf, buf);
@@ -2645,7 +2641,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
     }
     buf = curbuf;
     if (buf->b_fname != NULL) {
-      new_name = vim_strsave(buf->b_fname);
+      new_name = (char *)vim_strsave(buf->b_fname);
     } else {
       new_name = NULL;
     }
@@ -2769,10 +2765,10 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
     // keep it.  Also when it moves within a line. But not when it moves
     // to the first non-blank.
     if (!equalpos(curwin->w_cursor, orig_pos)) {
-      const char_u *text = get_cursor_line_ptr();
+      const char *text = (char *)get_cursor_line_ptr();
 
       if (curwin->w_cursor.lnum != orig_pos.lnum
-          || curwin->w_cursor.col != (int)(skipwhite(text) - text)) {
+          || curwin->w_cursor.col != (int)(skipwhite((char_u *)text) - (char_u *)text)) {
         newlnum = curwin->w_cursor.lnum;
         newcol = curwin->w_cursor.col;
       }
@@ -2859,7 +2855,7 @@ int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T new
   curbuf->b_last_used = time(NULL);
 
   if (command != NULL) {
-    do_cmdline((char *)command, NULL, NULL, DOCMD_VERBOSE);
+    do_cmdline(command, NULL, NULL, DOCMD_VERBOSE);
   }
 
   if (curbuf->b_kmap_state & KEYMAP_INIT) {
@@ -2902,10 +2898,10 @@ theend:
   return retval;
 }
 
-static void delbuf_msg(char_u *name)
+static void delbuf_msg(char *name)
 {
   semsg(_("E143: Autocommands unexpectedly deleted new buffer %s"),
-        name == NULL ? (char_u *)"" : name);
+        name == NULL ? "" : name);
   xfree(name);
   au_new_curbuf.br_buf = NULL;
   au_new_curbuf.br_buf_free_count = 0;
@@ -2916,11 +2912,11 @@ static int append_indent = 0;       // autoindent for first line
 /// ":insert" and ":append", also used by ":change"
 void ex_append(exarg_T *eap)
 {
-  char_u *theline;
+  char *theline;
   bool did_undo = false;
   linenr_T lnum = eap->line2;
   int indent = 0;
-  char_u *p;
+  char *p;
   int vcol;
   int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
 
@@ -2965,22 +2961,22 @@ void ex_append(exarg_T *eap)
       if (eap->nextcmd == NULL || *eap->nextcmd == NUL) {
         break;
       }
-      p = vim_strchr(eap->nextcmd, NL);
+      p = (char *)vim_strchr(eap->nextcmd, NL);
       if (p == NULL) {
-        p = eap->nextcmd + STRLEN(eap->nextcmd);
+        p = (char *)eap->nextcmd + STRLEN(eap->nextcmd);
       }
-      theline = vim_strnsave(eap->nextcmd, p - eap->nextcmd);
+      theline = (char *)vim_strnsave(eap->nextcmd, (char_u *)p - eap->nextcmd);
       if (*p != NUL) {
         p++;
       }
-      eap->nextcmd = p;
+      eap->nextcmd = (char_u *)p;
     } else {
       // Set State to avoid the cursor shape to be set to INSERT mode
       // when getline() returns.
       int save_State = State;
       State = CMDLINE;
-      theline = eap->getline(eap->cstack->cs_looplevel > 0 ? -1 :
-                             NUL, eap->cookie, indent, true);
+      theline = (char *)eap->getline(eap->cstack->cs_looplevel > 0 ? -1 :
+                                     NUL, eap->cookie, indent, true);
       State = save_State;
     }
     lines_left = Rows - 1;
@@ -3012,7 +3008,7 @@ void ex_append(exarg_T *eap)
     }
 
     did_undo = true;
-    ml_append(lnum, theline, (colnr_T)0, false);
+    ml_append(lnum, (char_u *)theline, (colnr_T)0, false);
     if (empty) {
       // there are no marks below the inserted lines
       appended_lines(lnum, 1L);
@@ -3088,9 +3084,9 @@ void ex_change(exarg_T *eap)
 
 void ex_z(exarg_T *eap)
 {
-  char_u *x;
+  char *x;
   int64_t bigness;
-  char_u *kind;
+  char *kind;
   int minus = 0;
   linenr_T start, end, curs, i;
   int j;
@@ -3109,7 +3105,7 @@ void ex_z(exarg_T *eap)
     bigness = 1;
   }
 
-  x = eap->arg;
+  x = (char *)eap->arg;
   kind = x;
   if (*kind == '-' || *kind == '+' || *kind == '='
       || *kind == '^' || *kind == '.') {
@@ -3124,7 +3120,7 @@ void ex_z(exarg_T *eap)
       emsg(_("E144: non-numeric argument to :z"));
       return;
     }
-    bigness = atol((char *)x);
+    bigness = atol(x);
 
     // bigness could be < 0 if atol(x) overflows.
     if (bigness > 2 * curbuf->b_ml.ml_line_count || bigness < 0) {
@@ -3279,7 +3275,7 @@ void sub_set_replacement(SubReplacementString sub)
 /// @param[in]  save Save pattern to options, history
 ///
 /// @returns true if :substitute can be replaced with a join command
-static bool sub_joining_lines(exarg_T *eap, char_u *pat, char_u *sub, char_u *cmd, bool save)
+static bool sub_joining_lines(exarg_T *eap, char *pat, char *sub, char *cmd, bool save)
   FUNC_ATTR_NONNULL_ARG(1, 3, 4)
 {
   // TODO(vim): find a generic solution to make line-joining operations more
@@ -3318,9 +3314,9 @@ static bool sub_joining_lines(exarg_T *eap, char_u *pat, char_u *sub, char_u *cm
 
     if (save) {
       if (!cmdmod.keeppatterns) {
-        save_re_pat(RE_SUBST, pat, p_magic);
+        save_re_pat(RE_SUBST, (char_u *)pat, p_magic);
       }
-      add_to_history(HIST_SEARCH, pat, true, NUL);
+      add_to_history(HIST_SEARCH, (char_u *)pat, true, NUL);
     }
 
     return true;
@@ -3338,11 +3334,11 @@ static bool sub_joining_lines(exarg_T *eap, char_u *pat, char_u *sub, char_u *cm
 /// @param[in]      needed_len  amount of memory needed
 ///
 /// @returns pointer to the end of the allocated memory
-static char_u *sub_grow_buf(char_u **new_start, int needed_len)
+static char *sub_grow_buf(char **new_start, int needed_len)
   FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_NONNULL_RET
 {
   int new_start_len = 0;
-  char_u *new_end;
+  char *new_end;
   if (*new_start == NULL) {
     // Get some space for a temporary buffer to do the
     // substitution into (and some extra space to avoid
@@ -3374,7 +3370,7 @@ static char_u *sub_grow_buf(char_u **new_start, int needed_len)
 /// @param[in,out]  which_pat  pattern type from which to get default search
 ///
 /// @returns pointer to the end of the flags, which may be the end of the string
-static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags, int *which_pat)
+static char *sub_parse_flags(char *cmd, subflags_T *subflags, int *which_pat)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET
 {
   // Find trailing options.  When '&' is used, keep old options.
@@ -3460,18 +3456,18 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
     .do_number = false,
     .do_ic = kSubHonorOptions
   };
-  char_u *pat = NULL, *sub = NULL;  // init for GCC
+  char *pat = NULL, *sub = NULL;  // init for GCC
   int delimiter;
   bool has_second_delim = false;
   int sublen;
   bool got_quit = false;
   bool got_match = false;
   int which_pat;
-  char_u *cmd = eap->arg;
+  char *cmd = (char *)eap->arg;
   linenr_T first_line = 0;  // first changed line
   linenr_T last_line= 0;    // below last changed line AFTER the change
   linenr_T old_line_count = curbuf->b_ml.ml_line_count;
-  char_u *sub_firstline;    // allocated copy of first sub line
+  char *sub_firstline;    // allocated copy of first sub line
   bool endcolumn = false;   // cursor in last column when done
   PreviewLines preview_lines = { KV_INITIAL_VALUE, 0 };
   static int pre_src_id = 0;  // Source id for the preview highlight
@@ -3516,14 +3512,14 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
       if (*cmd != '&') {
         which_pat = RE_SEARCH;              // use last '/' pattern
       }
-      pat = (char_u *)"";                   // empty search pattern
-      delimiter = *cmd++;                   // remember delimiter character
+      pat = "";                   // empty search pattern
+      delimiter = (char_u)(*cmd++);                   // remember delimiter character
       has_second_delim = true;
     } else {          // find the end of the regexp
       which_pat = RE_LAST;                  // use last used regexp
-      delimiter = *cmd++;                   // remember delimiter character
+      delimiter = (char_u)(*cmd++);                   // remember delimiter character
       pat = cmd;                            // remember start of search pat
-      cmd = skip_regexp(cmd, delimiter, p_magic, &eap->arg);
+      cmd = (char *)skip_regexp((char_u *)cmd, delimiter, p_magic, &eap->arg);
       if (cmd[0] == delimiter) {            // end delimiter found
         *cmd++ = NUL;                       // replace it with a NUL
         has_second_delim = true;
@@ -3549,7 +3545,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
 
     if (!eap->skip && !preview) {
       sub_set_replacement((SubReplacementString) {
-        .sub = xstrdup((char *)sub),
+        .sub = xstrdup(sub),
         .timestamp = os_time(),
         .additional_elements = NULL,
       });
@@ -3560,7 +3556,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
       return NULL;
     }
     pat = NULL;                 // search_regcomp() will use previous pattern
-    sub = (char_u *)old_sub.sub;
+    sub = old_sub.sub;
 
     // Vi compatibility quirk: repeating with ":s" keeps the cursor in the
     // last column after using "$".
@@ -3577,9 +3573,9 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
   bool save_do_ask = subflags.do_ask;  // remember user specified 'c' flag
 
   // check for a trailing count
-  cmd = skipwhite(cmd);
+  cmd = (char *)skipwhite((char_u *)cmd);
   if (ascii_isdigit(*cmd)) {
-    i = getdigits_long(&cmd, true, 0);
+    i = getdigits_long((char_u **)&cmd, true, 0);
     if (i <= 0 && !eap->skip && subflags.do_error) {
       emsg(_(e_zerocount));
       return NULL;
@@ -3594,9 +3590,9 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
   /*
    * check for trailing command or garbage
    */
-  cmd = skipwhite(cmd);
+  cmd = (char *)skipwhite((char_u *)cmd);
   if (*cmd && *cmd != '"') {        // if not end-of-line or comment
-    eap->nextcmd = check_nextcmd(cmd);
+    eap->nextcmd = check_nextcmd((char_u *)cmd);
     if (eap->nextcmd == NULL) {
       emsg(_(e_trailing));
       return NULL;
@@ -3613,7 +3609,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
     return NULL;
   }
 
-  if (search_regcomp(pat, RE_SUBST, which_pat, (preview ? 0 : SEARCH_HIS),
+  if (search_regcomp((char_u *)pat, RE_SUBST, which_pat, (preview ? 0 : SEARCH_HIS),
                      &regmatch) == FAIL) {
     if (subflags.do_error) {
       emsg(_(e_invcmd));
@@ -3633,7 +3629,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
   assert(sub != NULL);
 
   bool sub_needs_free = false;
-  char_u *sub_copy = NULL;
+  char *sub_copy = NULL;
 
   // If the substitute pattern starts with "\=" then it's an expression.
   // Make a copy, a recursive function may free it.
@@ -3641,11 +3637,11 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
   // pattern.  We do it here once to avoid it to be replaced over and over
   // again.
   if (sub[0] == '\\' && sub[1] == '=') {
-    sub = vim_strsave(sub);
+    sub = xstrdup(sub);
     sub_copy = sub;
   } else {
-    char_u *source = sub;
-    sub = regtilde(sub, p_magic, preview);
+    char *source = sub;
+    sub = (char *)regtilde((char_u *)sub, p_magic, preview);
     // When previewing, the new pattern allocated by regtilde() needs to be freed
     // in this function because it will not be used or freed by regtilde() later.
     sub_needs_free = preview && sub != source;
@@ -3666,8 +3662,8 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
       colnr_T copycol;
       colnr_T matchcol;
       colnr_T prev_matchcol = MAXCOL;
-      char_u *new_end, *new_start = NULL;
-      char_u *p1;
+      char *new_end, *new_start = NULL;
+      char *p1;
       bool did_sub = false;
       int lastone;
       long nmatch_tl = 0;               // nr of lines matched below lnum
@@ -3767,7 +3763,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
           break;
         }
         if (sub_firstline == NULL) {
-          sub_firstline = vim_strsave(ml_get(sub_firstlnum));
+          sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum));
         }
 
         // Save the line number of the last change for the final
@@ -3789,7 +3785,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
             skip_match = true;
           } else {
             // search for a match at next column
-            matchcol += utfc_ptr2len(sub_firstline + matchcol);
+            matchcol += utfc_ptr2len((char_u *)sub_firstline + matchcol);
           }
           // match will be pushed to preview_lines, bring it into a proper state
           current_match.start.col = matchcol;
@@ -3850,7 +3846,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
           while (subflags.do_ask) {
             if (exmode_active) {
               char *prompt;
-              char_u *resp;
+              char *resp;
               colnr_T sc, ec;
 
               print_line_no_prefix(lnum, subflags.do_number, subflags.do_list);
@@ -3870,12 +3866,11 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
               prompt = xmallocz(ec + 1);
               memset(prompt, ' ', sc);
               memset(prompt + sc, '^', ec - sc + 1);
-              resp = (char_u *)getcmdline_prompt(-1, prompt, 0, EXPAND_NOTHING,
-                                                 NULL, CALLBACK_NONE);
+              resp = getcmdline_prompt(-1, prompt, 0, EXPAND_NOTHING, NULL, CALLBACK_NONE);
               msg_putchar('\n');
               xfree(prompt);
               if (resp != NULL) {
-                typed = *resp;
+                typed = (char_u)(*resp);
                 xfree(resp);
               } else {
                 // getcmdline_prompt() returns NULL if there is no command line to return.
@@ -3888,7 +3883,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
                 typed = 'q';
               }
             } else {
-              char_u *orig_line = NULL;
+              char *orig_line = NULL;
               int len_change = 0;
               const bool save_p_lz = p_lz;
               int save_p_fen = curwin->w_p_fen;
@@ -3908,15 +3903,16 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
                 // really update the line, it would change
                 // what matches.  Temporarily replace the line
                 // and change it back afterwards.
-                orig_line = vim_strsave(ml_get(lnum));
-                char_u *new_line = concat_str(new_start, sub_firstline + copycol);
+                orig_line = (char *)vim_strsave(ml_get(lnum));
+                char *new_line = (char *)concat_str((char_u *)new_start,
+                                                    (char_u *)sub_firstline + copycol);
 
                 // Position the cursor relative to the end of the line, the
                 // previous substitute may have inserted or deleted characters
                 // before the cursor.
                 len_change = (int)STRLEN(new_line) - (int)STRLEN(orig_line);
                 curwin->w_cursor.col += len_change;
-                ml_replace(lnum, new_line, false);
+                ml_replace(lnum, (char_u *)new_line, false);
               }
 
               search_match_lines = regmatch.endpos[0].lnum
@@ -3963,7 +3959,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
 
               // restore the line
               if (orig_line != NULL) {
-                ml_replace(lnum, orig_line, false);
+                ml_replace(lnum, (char_u *)orig_line, false);
               }
             }
 
@@ -4036,7 +4032,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
     if (nmatch > 1) { \
       sub_firstlnum += nmatch - 1; \
       xfree(sub_firstline); \
-      sub_firstline = vim_strsave(ml_get(sub_firstlnum)); \
+      sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum)); \
       /* When going beyond the last line, stop substituting. */ \
       if (sub_firstlnum <= line2) { \
         do_again = true; \
@@ -4048,7 +4044,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
       /* Already hit end of the buffer, sub_firstlnum is one */ \
       /* less than what it ought to be. */ \
       xfree(sub_firstline); \
-      sub_firstline = vim_strsave((char_u *)""); \
+      sub_firstline = xstrdup(""); \
       copycol = 0; \
     } \
   } while (0)
@@ -4086,7 +4082,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
           // get length of substitution part
           sublen = vim_regsub_multi(&regmatch,
                                     sub_firstlnum - regmatch.startpos[0].lnum,
-                                    sub, sub_firstline, false, p_magic, true);
+                                    (char_u *)sub, (char_u *)sub_firstline, false, p_magic, true);
           // If getting the substitute string caused an error, don't do
           // the replacement.
           // Don't keep flags set by a recursive call
@@ -4107,7 +4103,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
           if (nmatch == 1) {
             p1 = sub_firstline;
           } else {
-            p1 = ml_get(sub_firstlnum + nmatch - 1);
+            p1 = (char *)ml_get(sub_firstlnum + nmatch - 1);
             nmatch_tl += nmatch - 1;
           }
           size_t copy_len = regmatch.startpos[0].col - copycol;
@@ -4126,7 +4122,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
 
           (void)vim_regsub_multi(&regmatch,
                                  sub_firstlnum - regmatch.startpos[0].lnum,
-                                 sub, new_end, true, p_magic, true);
+                                 (char_u *)sub, (char_u *)new_end, true, p_magic, true);
           sub_nsubs++;
           did_sub = true;
 
@@ -4160,7 +4156,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
             } else if (*p1 == CAR) {
               if (u_inssub(lnum) == OK) {             // prepare for undo
                 *p1 = NUL;                            // truncate up to the CR
-                ml_append(lnum - 1, new_start,
+                ml_append(lnum - 1, (char_u *)new_start,
                           (colnr_T)(p1 - new_start + 1), false);
                 mark_adjust(lnum + 1, (linenr_T)MAXLNUM, 1L, 0L, kExtmarkNOOP);
 
@@ -4183,7 +4179,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout, bool do_buf_event, handle
                 p1 = new_start - 1;
               }
             } else {
-              p1 += utfc_ptr2len(p1) - 1;
+              p1 += utfc_ptr2len((char_u *)p1) - 1;
             }
           }
           size_t new_endcol = STRLEN(new_start);
@@ -4254,7 +4250,7 @@ skip:
             if (u_savesub(lnum) != OK) {
               break;
             }
-            ml_replace(lnum, new_start, true);
+            ml_replace(lnum, (char_u *)new_start, true);
 
             if (nmatch_tl > 0) {
               /*
@@ -4522,14 +4518,14 @@ bool do_sub_msg(bool count_only)
   return false;
 }
 
-static void global_exe_one(char_u *const cmd, const linenr_T lnum)
+static void global_exe_one(char *const cmd, const linenr_T lnum)
 {
   curwin->w_cursor.lnum = lnum;
   curwin->w_cursor.col = 0;
   if (*cmd == NUL || *cmd == '\n') {
     do_cmdline("p", NULL, NULL, DOCMD_NOWAIT);
   } else {
-    do_cmdline((char *)cmd, NULL, NULL, DOCMD_NOWAIT);
+    do_cmdline(cmd, NULL, NULL, DOCMD_NOWAIT);
   }
 }
 
@@ -4552,10 +4548,10 @@ void ex_global(exarg_T *eap)
   linenr_T lnum;                // line number according to old situation
   int ndone = 0;
   int type;                     // first char of cmd: 'v' or 'g'
-  char_u *cmd;             // command argument
+  char *cmd;             // command argument
 
-  char_u delim;                 // delimiter, normally '/'
-  char_u *pat;
+  char delim;                 // delimiter, normally '/'
+  char *pat;
   regmmatch_T regmatch;
   int match;
   int which_pat;
@@ -4572,9 +4568,9 @@ void ex_global(exarg_T *eap)
   if (eap->forceit) {               // ":global!" is like ":vglobal"
     type = 'v';
   } else {
-    type = *eap->cmd;
+    type = (uint8_t)(*eap->cmd);
   }
-  cmd = eap->arg;
+  cmd = (char *)eap->arg;
   which_pat = RE_LAST;              // default: use last used regexp
 
   /*
@@ -4593,8 +4589,8 @@ void ex_global(exarg_T *eap)
     } else {
       which_pat = RE_SEARCH;            // use previous search pattern
     }
-    ++cmd;
-    pat = (char_u *)"";
+    cmd++;
+    pat = "";
   } else if (*cmd == NUL) {
     emsg(_("E148: Regular expression missing from global"));
     return;
@@ -4604,13 +4600,13 @@ void ex_global(exarg_T *eap)
     delim = *cmd;               // get the delimiter
     cmd++;                      // skip delimiter if there is one
     pat = cmd;                  // remember start of pattern
-    cmd = skip_regexp(cmd, delim, p_magic, &eap->arg);
+    cmd = (char *)skip_regexp((char_u *)cmd, delim, p_magic, &eap->arg);
     if (cmd[0] == delim) {                  // end delimiter found
       *cmd++ = NUL;                         // replace it with a NUL
     }
   }
 
-  if (search_regcomp(pat, RE_BOTH, which_pat, SEARCH_HIS, &regmatch) == FAIL) {
+  if (search_regcomp((char_u *)pat, RE_BOTH, which_pat, SEARCH_HIS, &regmatch) == FAIL) {
     emsg(_(e_invcmd));
     return;
   }
@@ -4656,7 +4652,7 @@ void ex_global(exarg_T *eap)
 }
 
 /// Execute `cmd` on lines marked with ml_setmarked().
-void global_exe(char_u *cmd)
+void global_exe(char *cmd)
 {
   linenr_T old_lcount;      // b_ml.ml_line_count before the command
   buf_T *old_buf = curbuf;  // remember what buffer we started in
@@ -4759,20 +4755,20 @@ bool prepare_tagpreview(bool undo_sync)
 /// ":help": open a read-only window on a help file
 void ex_help(exarg_T *eap)
 {
-  char_u *arg;
-  char_u *tag;
+  char *arg;
+  char *tag;
   FILE *helpfd;          // file descriptor of help file
   int n;
   int i;
   win_T *wp;
   int num_matches;
-  char_u **matches;
-  char_u *p;
+  char **matches;
+  char *p;
   int empty_fnum = 0;
   int alt_fnum = 0;
   buf_T *buf;
   int len;
-  char_u *lang;
+  char *lang;
   const bool old_KeyTyped = KeyTyped;
 
   if (eap != NULL) {
@@ -4780,15 +4776,15 @@ void ex_help(exarg_T *eap)
      * A ":help" command ends at the first LF, or at a '|' that is
      * followed by some text.  Set nextcmd to the following command.
      */
-    for (arg = eap->arg; *arg; ++arg) {
+    for (arg = (char *)eap->arg; *arg; arg++) {
       if (*arg == '\n' || *arg == '\r'
           || (*arg == '|' && arg[1] != NUL && arg[1] != '|')) {
         *arg++ = NUL;
-        eap->nextcmd = arg;
+        eap->nextcmd = (char_u *)arg;
         break;
       }
     }
-    arg = eap->arg;
+    arg = (char *)eap->arg;
 
     if (eap->forceit && *arg == NUL && !curbuf->b_help) {
       emsg(_("E478: Don't panic!"));
@@ -4799,7 +4795,7 @@ void ex_help(exarg_T *eap)
       return;
     }
   } else {
-    arg = (char_u *)"";
+    arg = "";
   }
 
   // remove trailing blanks
@@ -4813,14 +4809,13 @@ void ex_help(exarg_T *eap)
 
   // When no argument given go to the index.
   if (*arg == NUL) {
-    arg = (char_u *)"help.txt";
+    arg = "help.txt";
   }
 
   /*
    * Check if there is a match for the argument.
    */
-  n = find_help_tags(arg, &num_matches, &matches,
-                     eap != NULL && eap->forceit);
+  n = find_help_tags(arg, &num_matches, &matches, eap != NULL && eap->forceit);
 
   i = 0;
   if (n != FAIL && lang != NULL) {
@@ -4840,14 +4835,14 @@ void ex_help(exarg_T *eap)
       semsg(_("E149: Sorry, no help for %s"), arg);
     }
     if (n != FAIL) {
-      FreeWild(num_matches, matches);
+      FreeWild(num_matches, (char_u **)matches);
     }
     return;
   }
 
   // The first match (in the requested language) is the best match.
-  tag = vim_strsave(matches[i]);
-  FreeWild(num_matches, matches);
+  tag = xstrdup(matches[i]);
+  FreeWild(num_matches, (char_u **)matches);
 
   /*
    * Re-use an existing help window or open a new one.
@@ -4917,7 +4912,7 @@ void ex_help(exarg_T *eap)
   // It is needed for do_tag top open folds under the cursor.
   KeyTyped = old_KeyTyped;
 
-  do_tag(tag, DT_HELP, 1, FALSE, TRUE);
+  do_tag((char_u *)tag, DT_HELP, 1, false, true);
 
   // Delete the empty buffer if we're not using it.  Careful: autocommands
   // may have jumped to another window, check that the buffer is not in a
@@ -4943,7 +4938,7 @@ erret:
 /// Changes the "@" to NUL if found, and returns a pointer to "xx".
 ///
 /// @return  NULL if not found.
-char_u *check_help_lang(char_u *arg)
+char *check_help_lang(char *arg)
 {
   int len = (int)STRLEN(arg);
 
@@ -4969,11 +4964,11 @@ char_u *check_help_lang(char_u *arg)
 /// @param wrong_case  no matching case
 ///
 /// @return  a heuristic indicating how well the given string matches.
-int help_heuristic(char_u *matched_string, int offset, int wrong_case)
+int help_heuristic(char *matched_string, int offset, int wrong_case)
   FUNC_ATTR_PURE
 {
   int num_letters;
-  char_u *p;
+  char *p;
 
   num_letters = 0;
   for (p = matched_string; *p; p++) {
@@ -5025,7 +5020,7 @@ static int help_compare(const void *s1, const void *s2)
 /// the number of matches in num_matches.
 /// The matches will be sorted with a "best" match algorithm.
 /// When "keep_lang" is true try keeping the language of the current buffer.
-int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool keep_lang)
+int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep_lang)
 {
   int i;
   static const char *(mtable[]) = {
@@ -5058,7 +5053,7 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
     "!=?", "!~?", "<=?", "<?", "==?", "=~?",
     ">=?", ">?", "is?", "isnot?"
   };
-  char_u *d = IObuff;       // assume IObuff is long enough!
+  char *d = (char *)IObuff;       // assume IObuff is long enough!
 
   if (STRNICMP(arg, "expr-", 5) == 0) {
     // When the string starting with "expr-" and containing '?' and matches
@@ -5099,7 +5094,7 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
         && ((arg[1] != NUL && arg[2] == NUL)
             || (vim_strchr((char_u *)"%_z@", arg[1]) != NULL
                 && arg[2] != NUL))) {
-      vim_snprintf((char *)d, IOSIZE, "/\\\\%s", arg + 1);
+      vim_snprintf(d, IOSIZE, "/\\\\%s", arg + 1);
       // Check for "/\\_$", should be "/\\_\$"
       if (d[3] == '_' && d[4] == '$') {
         STRCPY(d + 4, "\\$");
@@ -5119,14 +5114,14 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
       if (*arg == '(' && arg[1] == '\'') {
         arg++;
       }
-      for (const char_u *s = arg; *s; s++) {
+      for (const char *s = arg; *s; s++) {
         // Replace "|" with "bar" and '"' with "quote" to match the name of
         // the tags for these commands.
         // Replace "*" with ".*" and "?" with "." to match command line
         // completion.
         // Insert a backslash before '~', '$' and '.' to avoid their
         // special meaning.
-        if (d - IObuff > IOSIZE - 10) {           // getting too long!?
+        if ((char_u *)d - IObuff > IOSIZE - 10) {           // getting too long!?
           break;
         }
         switch (*s) {
@@ -5160,7 +5155,7 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
                                                || vim_strchr((char_u *)
                                                              "?@[\\]^",
                                                              s[1]) != NULL))) {
-          if (d > IObuff && d[-1] != '_' && d[-1] != '\\') {
+          if ((char_u *)d > IObuff && d[-1] != '_' && d[-1] != '\\') {
             *d++ = '_';                 // prepend a '_' to make x_CTRL-x
           }
           STRCPY(d, "CTRL-");
@@ -5218,15 +5213,15 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
       *d = NUL;
 
       if (*IObuff == '`') {
-        if (d > IObuff + 2 && d[-1] == '`') {
+        if ((char_u *)d > IObuff + 2 && d[-1] == '`') {
           // remove the backticks from `command`
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
           d[-2] = NUL;
-        } else if (d > IObuff + 3 && d[-2] == '`' && d[-1] == ',') {
+        } else if ((char_u *)d > IObuff + 3 && d[-2] == '`' && d[-1] == ',') {
           // remove the backticks and comma from `command`,
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
           d[-3] = NUL;
-        } else if (d > IObuff + 4 && d[-3] == '`'
+        } else if ((char_u *)d > IObuff + 4 && d[-3] == '`'
                    && d[-2] == '\\' && d[-1] == '.') {
           // remove the backticks and dot from `command`\.
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
@@ -5242,7 +5237,7 @@ int find_help_tags(const char_u *arg, int *num_matches, char_u ***matches, bool
   if (keep_lang) {
     flags |= TAG_KEEP_LANG;
   }
-  if (find_tags(IObuff, num_matches, matches, flags, MAXCOL, NULL) == OK
+  if (find_tags(IObuff, num_matches, (char_u ***)matches, flags, MAXCOL, NULL) == OK
       && *num_matches > 0) {
     // Sort the matches found on the heuristic number that is after the
     // tag name.
@@ -5268,9 +5263,9 @@ static void prepare_help_buffer(void)
   // Accept all ASCII chars for keywords, except ' ', '*', '"', '|', and
   // latin1 word characters (for translated help files).
   // Only set it when needed, buf_init_chartab() is some work.
-  char_u *p = (char_u *)"!-~,^*,^|,^\",192-255";
+  char *p = "!-~,^*,^|,^\",192-255";
   if (STRCMP(curbuf->b_p_isk, p) != 0) {
-    set_string_option_direct("isk", -1, p, OPT_FREE|OPT_LOCAL, 0);
+    set_string_option_direct("isk", -1, (char_u *)p, OPT_FREE|OPT_LOCAL, 0);
     check_buf_options(curbuf);
     (void)buf_init_chartab(curbuf, FALSE);
   }
@@ -5301,7 +5296,7 @@ static void prepare_help_buffer(void)
 void fix_help_buffer(void)
 {
   linenr_T lnum;
-  char_u *line;
+  char *line;
   bool in_example = false;
 
   // Set filetype to "help".
@@ -5313,13 +5308,13 @@ void fix_help_buffer(void)
 
   if (!syntax_present(curwin)) {
     for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; lnum++) {
-      line = ml_get_buf(curbuf, lnum, false);
+      line = (char *)ml_get_buf(curbuf, lnum, false);
       const size_t len = STRLEN(line);
       if (in_example && len > 0 && !ascii_iswhite(line[0])) {
         // End of example: non-white or '<' in first column.
         if (line[0] == '<') {
           // blank-out a '<' in the first column
-          line = ml_get_buf(curbuf, lnum, true);
+          line = (char *)ml_get_buf(curbuf, lnum, true);
           line[0] = ' ';
         }
         in_example = false;
@@ -5327,12 +5322,12 @@ void fix_help_buffer(void)
       if (!in_example && len > 0) {
         if (line[len - 1] == '>' && (len == 1 || line[len - 2] == ' ')) {
           // blank-out a '>' in the last column (start of example)
-          line = ml_get_buf(curbuf, lnum, true);
+          line = (char *)ml_get_buf(curbuf, lnum, true);
           line[len - 1] = ' ';
           in_example = true;
         } else if (line[len - 1] == '~') {
           // blank-out a '~' at the end of line (header marker)
-          line = ml_get_buf(curbuf, lnum, true);
+          line = (char *)ml_get_buf(curbuf, lnum, true);
           line[len - 1] = ' ';
         }
       }
@@ -5343,7 +5338,7 @@ void fix_help_buffer(void)
    * In the "help.txt" and "help.abx" file, add the locally added help
    * files.  This uses the very first line in the help file.
    */
-  char_u *const fname = path_tail(curbuf->b_fname);
+  char *const fname = (char *)path_tail(curbuf->b_fname);
   if (FNAMECMP(fname, "help.txt") == 0
       || (FNAMENCMP(fname, "help.", 5) == 0
           && ASCII_ISALPHA(fname[5])
@@ -5351,24 +5346,24 @@ void fix_help_buffer(void)
           && TOLOWER_ASC(fname[7]) == 'x'
           && fname[8] == NUL)) {
     for (lnum = 1; lnum < curbuf->b_ml.ml_line_count; lnum++) {
-      line = ml_get_buf(curbuf, lnum, false);
-      if (strstr((char *)line, "*local-additions*") == NULL) {
+      line = (char *)ml_get_buf(curbuf, lnum, false);
+      if (strstr(line, "*local-additions*") == NULL) {
         continue;
       }
 
       // Go through all directories in 'runtimepath', skipping
       // $VIMRUNTIME.
-      char_u *p = p_rtp;
+      char *p = (char *)p_rtp;
       while (*p != NUL) {
-        copy_option_part(&p, NameBuff, MAXPATHL, ",");
-        char_u *const rt = (char_u *)vim_getenv("VIMRUNTIME");
+        copy_option_part((char_u **)&p, NameBuff, MAXPATHL, ",");
+        char *const rt = vim_getenv("VIMRUNTIME");
         if (rt != NULL
-            && path_full_compare(rt, NameBuff, false, true) != kEqualFiles) {
+            && path_full_compare((char_u *)rt, NameBuff, false, true) != kEqualFiles) {
           int fcount;
-          char_u **fnames;
-          char_u *s;
+          char **fnames;
+          char *s;
           vimconv_T vc;
-          char_u *cp;
+          char *cp;
 
           // Find all "doc/ *.txt" files in this directory.
           if (!add_pathsep((char *)NameBuff)
@@ -5380,9 +5375,9 @@ void fix_help_buffer(void)
 
           // Note: We cannot just do `&NameBuff` because it is a statically sized array
           //       so `NameBuff == &NameBuff` according to C semantics.
-          char_u *buff_list[1] = { NameBuff };
-          if (gen_expand_wildcards(1, buff_list, &fcount,
-                                   &fnames, EW_FILE|EW_SILENT) == OK
+          char *buff_list[1] = { (char *)NameBuff };
+          if (gen_expand_wildcards(1, (char_u **)buff_list, &fcount,
+                                   (char_u ***)&fnames, EW_FILE|EW_SILENT) == OK
               && fcount > 0) {
             // If foo.abx is found use it instead of foo.txt in
             // the same directory.
@@ -5394,12 +5389,12 @@ void fix_help_buffer(void)
                 if (fnames[i1] == NULL || fnames[i2] == NULL) {
                   continue;
                 }
-                const char_u *const f1 = fnames[i1];
-                const char_u *const f2 = fnames[i2];
-                const char_u *const t1 = path_tail(f1);
-                const char_u *const t2 = path_tail(f2);
-                const char_u *const e1 = STRRCHR(t1, '.');
-                const char_u *const e2 = STRRCHR(t2, '.');
+                const char *const f1 = fnames[i1];
+                const char *const f2 = fnames[i2];
+                const char *const t1 = (char *)path_tail((char_u *)f1);
+                const char *const t2 = (char *)path_tail((char_u *)f2);
+                const char *const e1 = (char *)STRRCHR(t1, '.');
+                const char *const e2 = (char *)STRRCHR(t2, '.');
                 if (e1 == NULL || e2 == NULL) {
                   continue;
                 }
@@ -5425,13 +5420,13 @@ void fix_help_buffer(void)
                 continue;
               }
 
-              FILE *const fd = os_fopen((char *)fnames[fi], "r");
+              FILE *const fd = os_fopen(fnames[fi], "r");
               if (fd == NULL) {
                 continue;
               }
               vim_fgets(IObuff, IOSIZE, fd);
               if (IObuff[0] == '*'
-                  && (s = vim_strchr(IObuff + 1, '*'))
+                  && (s = (char *)vim_strchr(IObuff + 1, '*'))
                   != NULL) {
                 TriState this_utf = kNone;
                 // Change tag definition to a
@@ -5445,9 +5440,9 @@ void fix_help_buffer(void)
                   // The text is utf-8 when a byte
                   // above 127 is found and no
                   // illegal byte sequence is found.
-                  if (*s >= 0x80 && this_utf != kFalse) {
+                  if ((char_u)(*s) >= 0x80 && this_utf != kFalse) {
                     this_utf = kTrue;
-                    const int l = utf_ptr2len(s);
+                    const int l = utf_ptr2len((char_u *)s);
                     if (l == 1) {
                       this_utf = kFalse;
                     }
@@ -5464,26 +5459,26 @@ void fix_help_buffer(void)
                               p_enc);
                 if (vc.vc_type == CONV_NONE) {
                   // No conversion needed.
-                  cp = IObuff;
+                  cp = (char *)IObuff;
                 } else {
                   // Do the conversion.  If it fails
                   // use the unconverted text.
-                  cp = string_convert(&vc, IObuff, NULL);
+                  cp = (char *)string_convert(&vc, IObuff, NULL);
                   if (cp == NULL) {
-                    cp = IObuff;
+                    cp = (char *)IObuff;
                   }
                 }
                 convert_setup(&vc, NULL, NULL);
 
-                ml_append(lnum, cp, (colnr_T)0, false);
-                if (cp != IObuff) {
+                ml_append(lnum, (char_u *)cp, (colnr_T)0, false);
+                if ((char_u *)cp != IObuff) {
                   xfree(cp);
                 }
                 lnum++;
               }
               fclose(fd);
             }
-            FreeWild(fcount, fnames);
+            FreeWild(fcount, (char_u **)fnames);
           }
         }
         xfree(rt);
@@ -5514,15 +5509,15 @@ void ex_viusage(exarg_T *eap)
 ///                 French)
 /// @param add_help_tags  Whether to add the "help-tags" tag
 /// @param ignore_writeerr  ignore write error
-static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname, bool add_help_tags,
+static void helptags_one(char *dir, const char *ext, const char *tagfname, bool add_help_tags,
                          bool ignore_writeerr)
   FUNC_ATTR_NONNULL_ALL
 {
   garray_T ga;
   int filecount;
-  char_u **files;
-  char_u *p1, *p2;
-  char_u *s;
+  char **files;
+  char *p1, *p2;
+  char *s;
   TriState utf8 = kNone;
   bool mix = false;             // detected mixed encodings
 
@@ -5537,8 +5532,8 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
 
   // Note: We cannot just do `&NameBuff` because it is a statically sized array
   //       so `NameBuff == &NameBuff` according to C semantics.
-  char_u *buff_list[1] = { NameBuff };
-  if (gen_expand_wildcards(1, buff_list, &filecount, &files,
+  char *buff_list[1] = { (char *)NameBuff };
+  if (gen_expand_wildcards(1, (char_u **)buff_list, &filecount, (char_u ***)&files,
                            EW_FILE|EW_SILENT) == FAIL
       || filecount == 0) {
     if (!got_int) {
@@ -5563,7 +5558,7 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
     if (!ignore_writeerr) {
       semsg(_("E152: Cannot open %s for writing"), NameBuff);
     }
-    FreeWild(filecount, files);
+    FreeWild(filecount, (char_u **)files);
     return;
   }
 
@@ -5572,31 +5567,31 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
   ga_init(&ga, (int)sizeof(char_u *), 100);
   if (add_help_tags
       || path_full_compare((char_u *)"$VIMRUNTIME/doc",
-                           dir, false, true) == kEqualFiles) {
+                           (char_u *)dir, false, true) == kEqualFiles) {
     size_t s_len = 18 + STRLEN(tagfname);
     s = xmalloc(s_len);
-    snprintf((char *)s, s_len, "help-tags\t%s\t1\n", tagfname);
-    GA_APPEND(char_u *, &ga, s);
+    snprintf(s, s_len, "help-tags\t%s\t1\n", tagfname);
+    GA_APPEND(char *, &ga, s);
   }
 
   // Go over all the files and extract the tags.
   for (int fi = 0; fi < filecount && !got_int; fi++) {
-    FILE *const fd = os_fopen((char *)files[fi], "r");
+    FILE *const fd = os_fopen(files[fi], "r");
     if (fd == NULL) {
       semsg(_("E153: Unable to open %s for reading"), files[fi]);
       continue;
     }
-    const char_u *const fname = files[fi] + dirlen + 1;
+    const char *const fname = files[fi] + dirlen + 1;
 
     bool firstline = true;
     while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int) {
       if (firstline) {
         // Detect utf-8 file by a non-ASCII char in the first line.
         TriState this_utf8 = kNone;
-        for (s = IObuff; *s != NUL; s++) {
-          if (*s >= 0x80) {
+        for (s = (char *)IObuff; *s != NUL; s++) {
+          if ((char_u)(*s) >= 0x80) {
             this_utf8 = kTrue;
-            const int l = utf_ptr2len(s);
+            const int l = utf_ptr2len((char_u *)s);
             if (l == 1) {
               // Illegal UTF-8 byte sequence.
               this_utf8 = kFalse;
@@ -5618,9 +5613,9 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
         }
         firstline = false;
       }
-      p1 = vim_strchr(IObuff, '*');                        // find first '*'
+      p1 = (char *)vim_strchr(IObuff, '*');                        // find first '*'
       while (p1 != NULL) {
-        p2 = (char_u *)strchr((const char *)p1 + 1, '*');  // Find second '*'.
+        p2 = strchr((const char *)p1 + 1, '*');  // Find second '*'.
         if (p2 != NULL && p2 > p1 + 1) {                   // Skip "*" and "**".
           for (s = p1 + 1; s < p2; s++) {
             if (*s == ' ' || *s == '\t' || *s == '|') {
@@ -5632,18 +5627,18 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
           // characters, there is white space before it and is
           // followed by a white character or end-of-line.
           if (s == p2
-              && (p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t')
+              && ((char_u *)p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t')
               && (vim_strchr((char_u *)" \t\n\r", s[1]) != NULL
                   || s[1] == '\0')) {
             *p2 = '\0';
             p1++;
             size_t s_len= (p2 - p1) + STRLEN(fname) + 2;
             s = xmalloc(s_len);
-            GA_APPEND(char_u *, &ga, s);
-            snprintf((char *)s, s_len, "%s\t%s", p1, fname);
+            GA_APPEND(char *, &ga, s);
+            snprintf(s, s_len, "%s\t%s", p1, fname);
 
             // find next '*'
-            p2 = vim_strchr(p2 + 1, '*');
+            p2 = (char *)vim_strchr((char_u *)p2 + 1, '*');
           }
         }
         p1 = p2;
@@ -5654,7 +5649,7 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
     fclose(fd);
   }
 
-  FreeWild(filecount, files);
+  FreeWild(filecount, (char_u **)files);
 
   if (!got_int && ga.ga_data != NULL) {
     // Sort the tags.
@@ -5662,8 +5657,8 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
 
     // Check for duplicates.
     for (int i = 1; i < ga.ga_len; i++) {
-      p1 = ((char_u **)ga.ga_data)[i - 1];
-      p2 = ((char_u **)ga.ga_data)[i];
+      p1 = ((char **)ga.ga_data)[i - 1];
+      p2 = ((char **)ga.ga_data)[i];
       while (*p1 == *p2) {
         if (*p2 == '\t') {
           *p2 = NUL;
@@ -5685,10 +5680,10 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
 
     // Write the tags into the file.
     for (int i = 0; i < ga.ga_len; i++) {
-      s = ((char_u **)ga.ga_data)[i];
+      s = ((char **)ga.ga_data)[i];
       if (STRNCMP(s, "help-tags\t", 10) == 0) {
         // help-tags entry was added in formatted form
-        fputs((char *)s, fd_tags);
+        fputs(s, fd_tags);
       } else {
         fprintf(fd_tags, "%s\t/" "*", s);
         for (p1 = s; *p1 != '\t'; p1++) {
@@ -5711,16 +5706,16 @@ static void helptags_one(char_u *dir, const char_u *ext, const char_u *tagfname,
 }
 
 /// Generate tags in one help directory, taking care of translations.
-static void do_helptags(char_u *dirname, bool add_help_tags, bool ignore_writeerr)
+static void do_helptags(char *dirname, bool add_help_tags, bool ignore_writeerr)
   FUNC_ATTR_NONNULL_ALL
 {
   int len;
   garray_T ga;
-  char_u lang[2];
-  char_u ext[5];
-  char_u fname[8];
+  char lang[2];
+  char ext[5];
+  char fname[8];
   int filecount;
-  char_u **files;
+  char **files;
 
   // Get a list of all files in the help directory and in subdirectories.
   STRLCPY(NameBuff, dirname, sizeof(NameBuff));
@@ -5732,8 +5727,8 @@ static void do_helptags(char_u *dirname, bool add_help_tags, bool ignore_writeer
 
   // Note: We cannot just do `&NameBuff` because it is a statically sized array
   //       so `NameBuff == &NameBuff` according to C semantics.
-  char_u *buff_list[1] = { NameBuff };
-  if (gen_expand_wildcards(1, buff_list, &filecount, &files,
+  char *buff_list[1] = { (char *)NameBuff };
+  if (gen_expand_wildcards(1, (char_u **)buff_list, &filecount, (char_u ***)&files,
                            EW_FILE|EW_SILENT) == FAIL
       || filecount == 0) {
     semsg(_("E151: No match: %s"), NameBuff);
@@ -5795,24 +5790,24 @@ static void do_helptags(char_u *dirname, bool add_help_tags, bool ignore_writeer
       ext[1] = fname[5];
       ext[2] = fname[6];
     }
-    helptags_one(dirname, ext, fname, add_help_tags, ignore_writeerr);
+    helptags_one(dirname, (char *)ext, (char *)fname, add_help_tags, ignore_writeerr);
   }
 
   ga_clear(&ga);
-  FreeWild(filecount, files);
+  FreeWild(filecount, (char_u **)files);
 }
 
 static void helptags_cb(char_u *fname, void *cookie)
   FUNC_ATTR_NONNULL_ALL
 {
-  do_helptags(fname, *(bool *)cookie, true);
+  do_helptags((char *)fname, *(bool *)cookie, true);
 }
 
 /// ":helptags"
 void ex_helptags(exarg_T *eap)
 {
   expand_T xpc;
-  char_u *dirname;
+  char *dirname;
   bool add_help_tags = false;
 
   // Check for ":helptags ++t {dir}".
@@ -5826,9 +5821,9 @@ void ex_helptags(exarg_T *eap)
   } else {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_DIRECTORIES;
-    dirname = ExpandOne(&xpc, eap->arg, NULL,
-                        WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
-    if (dirname == NULL || !os_isdir(dirname)) {
+    dirname = (char *)ExpandOne(&xpc, eap->arg, NULL,
+                                WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
+    if (dirname == NULL || !os_isdir((char_u *)dirname)) {
       semsg(_("E150: Not a directory: %s"), eap->arg);
     } else {
       do_helptags(dirname, add_help_tags, false);
@@ -5874,7 +5869,7 @@ static buf_T *show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines
 {
   win_T *save_curwin = curwin;
   cmdmod_T save_cmdmod = cmdmod;
-  char_u *save_shm_p = vim_strsave(p_shm);
+  char *save_shm_p = (char *)vim_strsave(p_shm);
   PreviewLines lines = *preview_lines;
   buf_T *orig_buf = curbuf;
 
@@ -6007,7 +6002,7 @@ static buf_T *show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines
   update_screen(SOME_VALID);
   RedrawingDisabled = save_rd;
 
-  set_string_option_direct("shm", -1, save_shm_p, OPT_FREE, SID_NONE);
+  set_string_option_direct("shm", -1, (char_u *)save_shm_p, OPT_FREE, SID_NONE);
   xfree(save_shm_p);
 
   cmdmod = save_cmdmod;
@@ -6043,7 +6038,7 @@ void ex_substitute(exarg_T *eap)
 
   block_autocmds();           // Disable events during command preview.
 
-  char_u *save_eap = eap->arg;
+  char *save_eap = (char *)eap->arg;
   garray_T save_view;
   win_size_save(&save_view);  // Save current window sizes.
   save_search_patterns();
@@ -6084,7 +6079,7 @@ void ex_substitute(exarg_T *eap)
   curbuf->b_p_ul = save_b_p_ul;
   curwin->w_p_cul = save_w_p_cul;   // Restore 'cursorline'
   curwin->w_p_cuc = save_w_p_cuc;   // Restore 'cursorcolumn'
-  eap->arg = save_eap;
+  eap->arg = (char_u *)save_eap;
   restore_search_patterns();
   win_size_restore(&save_view);
   ga_clear(&save_view);
@@ -6098,7 +6093,7 @@ void ex_substitute(exarg_T *eap)
 /// @param s      if not NULL, terminate the pattern with a NUL.
 ///
 /// @return  a pointer to the char just past the pattern plus flags.
-char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags)
+char *skip_vimgrep_pat(char *p, char **s, int *flags)
 {
   int c;
 
@@ -6107,7 +6102,7 @@ char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags)
     if (s != NULL) {
       *s = p;
     }
-    p = skiptowhite(p);
+    p = (char *)skiptowhite((char_u *)p);
     if (s != NULL && *p != NUL) {
       *p++ = NUL;
     }
@@ -6116,8 +6111,8 @@ char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags)
     if (s != NULL) {
       *s = p + 1;
     }
-    c = *p;
-    p = skip_regexp(p + 1, c, true, NULL);
+    c = (char_u)(*p);
+    p = (char *)skip_regexp((char_u *)p + 1, c, true, NULL);
     if (*p != c) {
       return NULL;
     }
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 38007e5ad4..c439b29cf6 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -565,8 +565,8 @@ void dialog_changed(buf_T *buf, bool checkall)
     if (buf->b_fname != NULL
         && check_overwrite(&ea,
                            buf,
-                           buf->b_fname,
-                           buf->b_ffname,
+                           (char *)buf->b_fname,
+                           (char *)buf->b_ffname,
                            false) == OK) {
       // didn't hit Cancel
       (void)buf_write_all(buf, false);
@@ -583,8 +583,8 @@ void dialog_changed(buf_T *buf, bool checkall)
         set_bufref(&bufref, buf2);
 
         if (buf2->b_fname != NULL
-            && check_overwrite(&ea, buf2, buf2->b_fname,
-                               buf2->b_ffname, false) == OK) {
+            && check_overwrite(&ea, buf2, (char *)buf2->b_fname,
+                               (char *)buf2->b_ffname, false) == OK) {
           // didn't hit Cancel
           (void)buf_write_all(buf2, false);
         }
@@ -1166,7 +1166,7 @@ void do_argfile(exarg_T *eap, int argn)
     // Edit the file; always use the last known line number.
     // When it fails (e.g. Abort for already edited file) restore the
     // argument index.
-    if (do_ecmd(0, alist_name(&ARGLIST[curwin->w_arg_idx]), NULL,
+    if (do_ecmd(0, (char *)alist_name(&ARGLIST[curwin->w_arg_idx]), NULL,
                 eap, ECMD_LAST,
                 (buf_hide(curwin->w_buffer) ? ECMD_HIDE : 0)
                 + (eap->forceit ? ECMD_FORCEIT : 0), curwin) == FAIL) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 83cf945608..7b5d14a404 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -1232,7 +1232,7 @@ static void set_cmd_addr_type(exarg_T *eap, char_u *p)
   }
   // :wincmd range depends on the argument
   if (eap->cmdidx == CMD_wincmd && p != NULL) {
-    get_wincmd_addr_type((char *)skipwhite((char_u *)p), eap);
+    get_wincmd_addr_type((char *)skipwhite(p), eap);
   }
   // :.cc in quickfix window uses line number
   if ((eap->cmdidx == CMD_cc || eap->cmdidx == CMD_ll) && bt_quickfix(curbuf)) {
@@ -2311,10 +2311,10 @@ int parse_command_modifiers(exarg_T *eap, char **errormsg, bool skip_only)
         }
       }
       if (skip_only) {
-        p = (char *)skip_vimgrep_pat((char_u *)p, NULL, NULL);
+        p = skip_vimgrep_pat(p, NULL, NULL);
       } else {
         // NOTE: This puts a NUL after the pattern.
-        p = (char *)skip_vimgrep_pat((char_u *)p, (char_u **)&reg_pat, NULL);
+        p = skip_vimgrep_pat(p, &reg_pat, NULL);
       }
       if (p == NULL || *p == NUL) {
         break;
@@ -3492,7 +3492,7 @@ const char *set_one_cmd_context(expand_T *xp, const char *buff)
 
   case CMD_filter:
     if (*arg != NUL) {
-      arg = (const char *)skip_vimgrep_pat((char_u *)arg, NULL, NULL);
+      arg = (const char *)skip_vimgrep_pat((char *)arg, NULL, NULL);
     }
     if (arg == NULL || *arg == NUL) {
       xp->xp_context = EXPAND_NOTHING;
@@ -4487,7 +4487,7 @@ static char *skip_grep_pat(exarg_T *eap)
                     || eap->cmdidx == CMD_vimgrepadd
                     || eap->cmdidx == CMD_lvimgrepadd
                     || grep_internal(eap->cmdidx))) {
-    p = (char *)skip_vimgrep_pat((char_u *)p, NULL, NULL);
+    p = skip_vimgrep_pat(p, NULL, NULL);
     if (p == NULL) {
       p = (char *)eap->arg;
     }
@@ -7676,7 +7676,7 @@ void do_exedit(exarg_T *eap, win_T *old_curwin)
     if (eap->cmdidx != CMD_balt && eap->cmdidx != CMD_badd) {
       setpcmark();
     }
-    if (do_ecmd(0, (eap->cmdidx == CMD_enew ? NULL : eap->arg),
+    if (do_ecmd(0, eap->cmdidx == CMD_enew ? NULL : (char *)eap->arg,
                 NULL, eap, eap->do_ecmd_lnum,
                 (buf_hide(curbuf) ? ECMD_HIDE : 0)
                 + (eap->forceit ? ECMD_FORCEIT : 0)
@@ -9758,7 +9758,7 @@ static void ex_folddo(exarg_T *eap)
     }
   }
 
-  global_exe(eap->arg);  // Execute the command on the marked lines.
+  global_exe((char *)eap->arg);  // Execute the command on the marked lines.
   ml_clearmarked();      // clear rest of the marks
 }
 
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 6550c5cbf3..cd8ade33c8 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -4932,8 +4932,8 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char_u **
   if (xp->xp_context == EXPAND_HELP) {
     /* With an empty argument we would get all the help tags, which is
      * very slow.  Get matches for "help" instead. */
-    if (find_help_tags(*pat == NUL ? (char_u *)"help" : pat,
-                       num_file, file, false) == OK) {
+    if (find_help_tags(*pat == NUL ? "help" : (char *)pat,
+                       num_file, (char ***)file, false) == OK) {
       cleanup_help_tags(*num_file, *file);
       return OK;
     }
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 480b5ab0b5..952064ab73 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1748,8 +1748,8 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
       // at the ATTENTION prompt close the window.
       swap_exists_did_quit = false;
       (void)do_ecmd(0, arg_idx < GARGCOUNT
-          ? alist_name(&GARGLIST[arg_idx]) : NULL,
-                    NULL, NULL, ECMD_LASTL, ECMD_HIDE, curwin);
+                    ? (char *)alist_name(&GARGLIST[arg_idx])
+                    : NULL, NULL, NULL, ECMD_LASTL, ECMD_HIDE, curwin);
       if (swap_exists_did_quit) {
         // abort or quit selected
         if (got_int || only_one_window()) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 373d3cdaa6..74ab50ce1d 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -4614,7 +4614,7 @@ static void nv_gotofile(cmdarg_T *cap)
       (void)autowrite(curbuf, false);
     }
     setpcmark();
-    if (do_ecmd(0, ptr, NULL, NULL, ECMD_LAST,
+    if (do_ecmd(0, (char *)ptr, NULL, NULL, ECMD_LAST,
                 buf_hide(curbuf) ? ECMD_HIDE : 0, curwin) == OK
         && cap->nchar == 'F' && lnum >= 0) {
       curwin->w_cursor.lnum = lnum;
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 9f22e303af..57cf4a44f5 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -746,7 +746,7 @@ char_u *get_cmd_output(char_u *cmd, char_u *infile, ShellOpts flags, size_t *ret
   }
 
   // Add the redirection stuff
-  char_u *command = make_filter_cmd(cmd, infile, tempname);
+  char_u *command = (char_u *)make_filter_cmd((char *)cmd, (char *)infile, (char *)tempname);
 
   // Call the shell to execute the command (errors are ignored).
   // Don't check timestamps here.
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index c4760e91fc..7c64b0aa0b 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -4394,7 +4394,7 @@ void ex_make(exarg_T *eap)
 
   char *const cmd = make_get_fullcmd((char *)eap->arg, fname);
 
-  do_shell((char_u *)cmd, 0);
+  do_shell(cmd, 0);
 
   incr_quickfix_busy();
 
@@ -5423,7 +5423,7 @@ static int vgr_process_args(exarg_T *eap, vgr_args_T *args)
   }
 
   // Get the search pattern: either white-separated or enclosed in //
-  char *p = (char *)skip_vimgrep_pat(eap->arg, (char_u **)&args->spat, &args->flags);
+  char *p = skip_vimgrep_pat((char *)eap->arg, &args->spat, &args->flags);
   if (p == NULL) {
     emsg(_(e_invalpat));
     return FAIL;
@@ -7238,7 +7238,7 @@ void ex_helpgrep(exarg_T *eap)
   incr_quickfix_busy();
 
   // Check for a specified language
-  char *const lang = (char *)check_help_lang(eap->arg);
+  char *const lang = check_help_lang((char *)eap->arg);
   regmatch_T regmatch = {
     .regprog = vim_regcomp(eap->arg, RE_MAGIC + RE_STRING),
     .rm_ic = false,
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 21b0e9440c..6df3a6a5ec 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -5808,7 +5808,7 @@ search_line:
             curwin->w_cursor.lnum = lnum;
             check_cursor();
           } else {
-            if (!GETFILE_SUCCESS(getfile(0, files[depth].name, NULL, true,
+            if (!GETFILE_SUCCESS(getfile(0, (char *)files[depth].name, NULL, true,
                                          files[depth].lnum, false))) {
               break;    // failed to jump to file
             }
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 83eb3d1832..40d65c2542 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -2097,8 +2097,8 @@ parse_line:
             STRCPY(p, tagp.tagname);
             p[len] = '@';
             STRCPY(p + len + 1, help_lang);
-            snprintf((char *)p + len + 1 + ML_EXTRA, 10, "%06d",
-                     help_heuristic(tagp.tagname,
+            snprintf((char *)p + len + 1 + ML_EXTRA, STRLEN(p) + len + 1 + ML_EXTRA, "%06d",
+                     help_heuristic((char *)tagp.tagname,
                                     match_re ? matchoff : 0, !match_no_ic)
                      + help_pri);
 
@@ -2795,7 +2795,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   if (getfile_result == GETFILE_UNUSED) {
     // Careful: getfile() may trigger autocommands and call jumpto_tag()
     // recursively.
-    getfile_result = getfile(0, fname, NULL, true, (linenr_T)0, forceit);
+    getfile_result = getfile(0, (char *)fname, NULL, true, (linenr_T)0, forceit);
   }
   keep_help_flag = false;
 
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 7d96532b8e..90f7145f51 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -489,7 +489,7 @@ wingotofile:
       setpcmark();
       if (win_split(0, 0) == OK) {
         RESET_BINDING(curwin);
-        if (do_ecmd(0, ptr, NULL, NULL, ECMD_LASTL, ECMD_HIDE, NULL) == FAIL) {
+        if (do_ecmd(0, (char *)ptr, NULL, NULL, ECMD_LASTL, ECMD_HIDE, NULL) == FAIL) {
           // Failed to open the file, close the window opened for it.
           win_close(curwin, false, false);
           goto_tabpage_win(oldtab, oldwin);