*: Make set_vim_var_\* functions have proper argument types

23 files changed, 365 insertions, 341 deletions

diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 1149ca1e62..a3063de869 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -658,9 +658,9 @@ void ex_diffupdate(exarg_T *eap)
   }
 
   // We need three temp file names.
-  char_u *tmp_orig = vim_tempname();
-  char_u *tmp_new = vim_tempname();
-  char_u *tmp_diff = vim_tempname();
+  char *tmp_orig = (char *) vim_tempname();
+  char *tmp_new = (char *) vim_tempname();
+  char *tmp_diff = (char *) vim_tempname();
 
   if ((tmp_orig == NULL) || (tmp_new == NULL) || (tmp_diff == NULL)) {
     goto theend;
@@ -670,11 +670,11 @@ void ex_diffupdate(exarg_T *eap)
   // are no differences.  Can't use the return value, it's non-zero when
   // there are differences.
   // May try twice, first with "-a" and then without.
-  int io_error = FALSE;
-  int ok = FALSE;
+  int io_error = false;
+  bool ok = false;
   for (;;) {
-    ok = FALSE;
-    FILE *fd = mch_fopen((char *)tmp_orig, "w");
+    ok = false;
+    FILE *fd = mch_fopen(tmp_orig, "w");
 
     if (fd == NULL) {
       io_error = TRUE;
@@ -683,7 +683,7 @@ void ex_diffupdate(exarg_T *eap)
         io_error = TRUE;
       }
       fclose(fd);
-      fd = mch_fopen((char *)tmp_new, "w");
+      fd = mch_fopen(tmp_new, "w");
 
       if (fd == NULL) {
         io_error = TRUE;
@@ -693,7 +693,7 @@ void ex_diffupdate(exarg_T *eap)
         }
         fclose(fd);
         diff_file(tmp_orig, tmp_new, tmp_diff);
-        fd = mch_fopen((char *)tmp_diff, "r");
+        fd = mch_fopen(tmp_diff, "r");
 
         if (fd == NULL) {
           io_error = TRUE;
@@ -712,10 +712,10 @@ void ex_diffupdate(exarg_T *eap)
           }
           fclose(fd);
         }
-        os_remove((char *)tmp_diff);
-        os_remove((char *)tmp_new);
+        os_remove(tmp_diff);
+        os_remove(tmp_new);
       }
-      os_remove((char *)tmp_orig);
+      os_remove(tmp_orig);
     }
 
     // When using 'diffexpr' break here.
@@ -756,7 +756,7 @@ void ex_diffupdate(exarg_T *eap)
 
   // Write the first buffer to a tempfile.
   buf_T *buf = curtab->tp_diffbuf[idx_orig];
-  if (diff_write(buf, tmp_orig) == FAIL) {
+  if (diff_write(buf, (char_u *) tmp_orig) == FAIL) {
     goto theend;
   }
 
@@ -767,17 +767,17 @@ void ex_diffupdate(exarg_T *eap)
       continue;  // skip buffer that isn't loaded
     }
 
-    if (diff_write(buf, tmp_new) == FAIL) {
+    if (diff_write(buf, (char_u *) tmp_new) == FAIL) {
       continue;
     }
     diff_file(tmp_orig, tmp_new, tmp_diff);
 
     // Read the diff output and add each entry to the diff list.
-    diff_read(idx_orig, idx_new, tmp_diff);
-    os_remove((char *)tmp_diff);
-    os_remove((char *)tmp_new);
+    diff_read(idx_orig, idx_new, (char_u *) tmp_diff);
+    os_remove(tmp_diff);
+    os_remove(tmp_new);
   }
-  os_remove((char *)tmp_orig);
+  os_remove(tmp_orig);
 
   // force updating cursor position on screen
   curwin->w_valid_cursor.lnum = 0;
@@ -795,15 +795,16 @@ theend:
 /// @param tmp_orig
 /// @param tmp_new
 /// @param tmp_diff
-static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff)
+static void diff_file(const char *const tmp_orig, const char *const tmp_new,
+                      const char *const tmp_diff)
 {
   if (*p_dex != NUL) {
     // Use 'diffexpr' to generate the diff file.
     eval_diff(tmp_orig, tmp_new, tmp_diff);
   } else {
-    size_t len = STRLEN(tmp_orig) + STRLEN(tmp_new) + STRLEN(tmp_diff)
-        + STRLEN(p_srr) + 27;
-    char_u *cmd = xmalloc(len);
+    const size_t len = (strlen(tmp_orig) + strlen(tmp_new) + strlen(tmp_diff)
+                        + STRLEN(p_srr) + 27);
+    char *const cmd = xmalloc(len);
 
     /* We don't want $DIFF_OPTIONS to get in the way. */
     if (os_getenv("DIFF_OPTIONS")) {
@@ -813,19 +814,17 @@ static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff)
     /* Build the diff command and execute it.  Always use -a, binary
      * differences are of no use.  Ignore errors, diff returns
      * non-zero when differences have been found. */
-    vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s",
-                 diff_a_works == FALSE ? "" : "-a ",
+    vim_snprintf(cmd, len, "diff %s%s%s%s%s %s",
+                 diff_a_works ? "-a " : "",
                  "",
                  (diff_flags & DIFF_IWHITE) ? "-b " : "",
                  (diff_flags & DIFF_ICASE) ? "-i " : "",
                  tmp_orig, tmp_new);
-    append_redir(cmd, len, p_srr, tmp_diff);
+    append_redir(cmd, len, (char *) p_srr, tmp_diff);
     block_autocmds();  // Avoid ShellCmdPost stuff
-    (void)call_shell(
-        cmd,
-        kShellOptFilter | kShellOptSilent | kShellOptDoOut,
-        NULL
-        );
+    (void)call_shell((char_u *) cmd,
+                     kShellOptFilter | kShellOptSilent | kShellOptDoOut,
+                     NULL);
     unblock_autocmds();
     xfree(cmd);
   }
@@ -902,9 +901,11 @@ void ex_diffpatch(exarg_T *eap)
   if (*p_pex != NUL) {
     // Use 'patchexpr' to generate the new file.
 #ifdef UNIX
-    eval_patch(tmp_orig, fullname != NULL ? fullname : eap->arg, tmp_new);
+    eval_patch((char *) tmp_orig,
+               (char *) (fullname != NULL ? fullname : eap->arg),
+               (char *) tmp_new);
 #else
-    eval_patch(tmp_orig, eap->arg, tmp_new);
+    eval_patch((char *) tmp_orig, (char *) eap->arg, (char *) tmp_new);
 #endif  // ifdef UNIX
   } else {
     // Build the patch command and execute it. Ignore errors. Switch to
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 614a5d43be..36c88df570 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -199,7 +199,7 @@ typedef struct insert_state {
   int did_restart_edit;              // remember if insert mode was restarted
                                      // after a ctrl+o
   bool nomove;
-  uint8_t *ptr;
+  char_u *ptr;
 } InsertState;
 
 
@@ -270,8 +270,8 @@ static void insert_enter(InsertState *s)
       s->ptr = (char_u *)"i";
     }
 
-    set_vim_var_string(VV_INSERTMODE, s->ptr, 1);
-    set_vim_var_string(VV_CHAR, NULL, -1);      /* clear v:char */
+    set_vim_var_string(VV_INSERTMODE, (char *) s->ptr, 1);
+    set_vim_var_string(VV_CHAR, NULL, -1);
     apply_autocmds(EVENT_INSERTENTER, NULL, NULL, false, curbuf);
 
     // Make sure the cursor didn't move.  Do call check_cursor_col() in
@@ -7239,15 +7239,15 @@ static void ins_insert(int replaceState)
     return;
   }
 
-  set_vim_var_string(VV_INSERTMODE,
-      (char_u *)((State & REPLACE_FLAG) ? "i" :
-                 replaceState == VREPLACE ? "v" :
-                 "r"), 1);
-  apply_autocmds(EVENT_INSERTCHANGE, NULL, NULL, FALSE, curbuf);
-  if (State & REPLACE_FLAG)
+  set_vim_var_string(VV_INSERTMODE, ((State & REPLACE_FLAG) ? "i" :
+                                     replaceState == VREPLACE ? "v" :
+                                     "r"), 1);
+  apply_autocmds(EVENT_INSERTCHANGE, NULL, NULL, false, curbuf);
+  if (State & REPLACE_FLAG) {
     State = INSERT | (State & LANGMAP);
-  else
+  } else {
     State = replaceState | (State & LANGMAP);
+  }
   AppendCharToRedobuff(K_INS);
   showmode();
   ui_cursor_shape();            /* may show different cursor shape */
@@ -8480,22 +8480,22 @@ static colnr_T get_nolist_virtcol(void)
  */
 static char_u *do_insert_char_pre(int c)
 {
-  char_u buf[MB_MAXBYTES + 1];
+  char buf[MB_MAXBYTES + 1];
 
   // Return quickly when there is nothing to do.
   if (!has_event(EVENT_INSERTCHARPRE)) {
     return NULL;
   }
   if (has_mbyte) {
-    buf[(*mb_char2bytes)(c, buf)] = NUL;
+    buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
   } else {
     buf[0] = c;
     buf[1] = NUL;
   }
 
-  /* Lock the text to avoid weird things from happening. */
-  ++textlock;
-  set_vim_var_string(VV_CHAR, buf, -1);    /* set v:char */
+  // Lock the text to avoid weird things from happening.
+  textlock++;
+  set_vim_var_string(VV_CHAR, buf, -1);
 
   char_u *res = NULL;
   if (apply_autocmds(EVENT_INSERTCHARPRE, NULL, NULL, FALSE, curbuf)) {
@@ -8506,8 +8506,8 @@ static char_u *do_insert_char_pre(int c)
       res = vim_strsave(get_vim_var_str(VV_CHAR));
   }
 
-  set_vim_var_string(VV_CHAR, NULL, -1);    /* clear v:char */
-  --textlock;
+  set_vim_var_string(VV_CHAR, NULL, -1);
+  textlock--;
 
   return res;
 }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index e23702ac16..204c0fb1ef 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -465,6 +465,8 @@ const list_T *eval_msgpack_type_lists[] = {
  */
 void eval_init(void)
 {
+  vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
+
   jobs = pmap_new(uint64_t)();
   struct vimvar   *p;
 
@@ -768,45 +770,50 @@ void var_redir_stop(void)
   redir_varname = NULL;
 }
 
-int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to)
+int eval_charconvert(const char *const enc_from, const char *const enc_to,
+                     const char *const fname_from, const char *const fname_to)
 {
-  int err = FALSE;
+  int err = false;
 
   set_vim_var_string(VV_CC_FROM, enc_from, -1);
   set_vim_var_string(VV_CC_TO, enc_to, -1);
   set_vim_var_string(VV_FNAME_IN, fname_from, -1);
   set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
-  if (eval_to_bool(p_ccv, &err, NULL, FALSE))
-    err = TRUE;
+  if (eval_to_bool(p_ccv, &err, NULL, false)) {
+    err = true;
+  }
   set_vim_var_string(VV_CC_FROM, NULL, -1);
   set_vim_var_string(VV_CC_TO, NULL, -1);
   set_vim_var_string(VV_FNAME_IN, NULL, -1);
   set_vim_var_string(VV_FNAME_OUT, NULL, -1);
 
-  if (err)
+  if (err) {
     return FAIL;
+  }
   return OK;
 }
 
-int eval_printexpr(char_u *fname, char_u *args)
+int eval_printexpr(const char *const fname, const char *const args)
 {
-  int err = FALSE;
+  int err = false;
 
   set_vim_var_string(VV_FNAME_IN, fname, -1);
   set_vim_var_string(VV_CMDARG, args, -1);
-  if (eval_to_bool(p_pexpr, &err, NULL, FALSE))
-    err = TRUE;
+  if (eval_to_bool(p_pexpr, &err, NULL, false)) {
+    err = true;
+  }
   set_vim_var_string(VV_FNAME_IN, NULL, -1);
   set_vim_var_string(VV_CMDARG, NULL, -1);
 
   if (err) {
-    os_remove((char *)fname);
+    os_remove(fname);
     return FAIL;
   }
   return OK;
 }
 
-void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile)
+void eval_diff(const char *const origfile, const char *const newfile,
+               const char *const outfile)
 {
   int err = FALSE;
 
@@ -819,7 +826,8 @@ void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile)
   set_vim_var_string(VV_FNAME_OUT, NULL, -1);
 }
 
-void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile)
+void eval_patch(const char *const origfile, const char *const difffile,
+                const char *const outfile)
 {
   int err;
 
@@ -17084,20 +17092,6 @@ static int eval_isnamec1(int c)
 }
 
 /*
- * Set number v: variable to "val".
- */
-void set_vim_var_nr(int idx, long val)
-{
-  vimvars[idx].vv_nr = val;
-}
-
-/// Set special v: variable to "val"
-void set_vim_var_special(const int idx, const SpecialVarValue val)
-{
-  vimvars[idx].vv_special = val;
-}
-
-/*
  * Get number v: variable value.
  */
 long get_vim_var_nr(int idx) FUNC_ATTR_PURE
@@ -17134,11 +17128,11 @@ dict_T *get_vim_var_dict(int idx) FUNC_ATTR_PURE
  */
 void set_vim_var_char(int c)
 {
-  char_u buf[MB_MAXBYTES + 1];
+  char buf[MB_MAXBYTES + 1];
 
-  if (has_mbyte)
-    buf[(*mb_char2bytes)(c, buf)] = NUL;
-  else {
+  if (has_mbyte) {
+    buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
+  } else {
     buf[0] = c;
     buf[1] = NUL;
   }
@@ -17157,47 +17151,68 @@ void set_vcount(long count, long count1, int set_prevcount)
   vimvars[VV_COUNT1].vv_nr = count1;
 }
 
-/*
- * Set string v: variable to a copy of "val".
- */
-void set_vim_var_string (
-    int idx,
-    char_u *val,
-    int len                    /* length of "val" to use or -1 (whole string) */
-)
+/// Set number v: variable to the given value
+///
+/// @param[in]  idx  Index of variable to set.
+/// @param[in]  val  Value to set to.
+void set_vim_var_nr(const VimVarIndex idx, const varnumber_T val)
 {
-  /* Need to do this (at least) once, since we can't initialize a union.
-   * Will always be invoked when "v:progname" is set. */
-  vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
+  vimvars[idx].vv_nr = val;
+}
+
+/// Set special v: variable to the given value
+///
+/// @param[in]  idx  Index of variable to set.
+/// @param[in]  val  Value to set to.
+void set_vim_var_special(const VimVarIndex idx, const SpecialVarValue val)
+{
+  vimvars[idx].vv_special = val;
+}
 
+/// Set string v: variable to the given string
+///
+/// @param[in]  idx  Index of variable to set.
+/// @param[in]  val  Value to set to. Will be copied.
+/// @param[in]  len  Legth of that value or -1 in which case strlen() will be
+///                  used.
+void set_vim_var_string(const VimVarIndex idx, const char *const val,
+                        const ptrdiff_t len)
+{
   xfree(vimvars[idx].vv_str);
-  if (val == NULL)
+  if (val == NULL) {
     vimvars[idx].vv_str = NULL;
-  else if (len == -1)
-    vimvars[idx].vv_str = vim_strsave(val);
-  else
-    vimvars[idx].vv_str = vim_strnsave(val, len);
+  } else if (len == -1) {
+    vimvars[idx].vv_str = (char_u *) xstrdup(val);
+  } else {
+    vimvars[idx].vv_str = (char_u *) xstrndup(val, (size_t) len);
+  }
 }
 
-/*
- * Set List v: variable to "val".
- */
-void set_vim_var_list(int idx, list_T *val)
+/// Set list v: variable to the given list
+///
+/// @param[in]  idx  Index of variable to set.
+/// @param[in,out]  val  Value to set to. Reference count will be incremented.
+void set_vim_var_list(const VimVarIndex idx, list_T *const val)
 {
   list_unref(vimvars[idx].vv_list);
   vimvars[idx].vv_list = val;
-  if (val != NULL)
-    ++val->lv_refcount;
+  if (val != NULL) {
+    val->lv_refcount++;
+  }
 }
 
-/// Set Dictionary v: variable to "val".
-void set_vim_var_dict(int idx, dict_T *val)
+/// Set Dictionary v: variable to the given dictionary
+///
+/// @param[in]  idx  Index of variable to set.
+/// @param[in,out]  val  Value to set to. Reference count will be incremented.
+///                      Also keys of the dictionary will be made read-only.
+void set_vim_var_dict(const VimVarIndex idx, dict_T *const val)
 {
   dict_unref(vimvars[idx].vv_dict);
   vimvars[idx].vv_dict = val;
 
   if (val != NULL) {
-    ++val->dv_refcount;
+    val->dv_refcount++;
     // Set readonly
     dict_set_keys_readonly(val);
   }
@@ -17208,15 +17223,17 @@ void set_vim_var_dict(int idx, dict_T *val)
  */
 void set_reg_var(int c)
 {
-  char_u regname;
+  char regname;
 
-  if (c == 0 || c == ' ')
+  if (c == 0 || c == ' ') {
     regname = '"';
-  else
+  } else {
     regname = c;
-  /* Avoid free/alloc when the value is already right. */
-  if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c)
+  }
+  // Avoid free/alloc when the value is already right.
+  if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c) {
     set_vim_var_string(VV_REG, &regname, 1);
+  }
 }
 
 /*
diff --git a/src/nvim/eval/decode.c b/src/nvim/eval/decode.c
index 10dd36c137..0774ef515f 100644
--- a/src/nvim/eval/decode.c
+++ b/src/nvim/eval/decode.c
@@ -575,8 +575,8 @@ parse_json_number_check:
     tv.vval.v_number = (varnumber_T) nr;
   }
   if (json_decoder_pop(OBJ(tv, false, *didcomma, *didcolon),
-                        stack, container_stack,
-                        &p, next_map_special, didcomma, didcolon) == FAIL) {
+                       stack, container_stack,
+                       &p, next_map_special, didcomma, didcolon) == FAIL) {
     goto parse_json_number_fail;
   }
   if (*next_map_special) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 5ea5beb478..d344daed11 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1326,15 +1326,17 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
 #endif
 
   size_t len = STRLEN(cmd) + 1;  // At least enough space for cmd + NULL.
-  
+
   len += is_fish_shell ?  sizeof("begin; ""; end") - 1
                        :  sizeof("("")") - 1;
 
-  if (itmp != NULL)
+  if (itmp != NULL) {
     len += STRLEN(itmp) + sizeof(" { "" < "" } ") - 1;
-  if (otmp != NULL)
+  }
+  if (otmp != NULL) {
     len += STRLEN(otmp) + STRLEN(p_srr) + 2;  // two extra spaces ("  "),
-  char_u *buf = xmalloc(len);
+  }
+  char *const buf = xmalloc(len);
 
 #if defined(UNIX)
   // Put delimiters around the command (for concatenated commands) when
@@ -1342,19 +1344,19 @@ 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((char *)buf, len, fmt, (char *)cmd);
+    vim_snprintf(buf, len, fmt, (char *)cmd);
   } else {
-    STRCPY(buf, cmd);
+    strncpy(buf, (char *) cmd, len);
   }
 
   if (itmp != NULL) {
-    STRCAT(buf, " < ");
-    STRCAT(buf, itmp);
+    strncat(buf, " < ", len);
+    strncat(buf, (char *) itmp, len);
   }
 #else
   // For shells that don't understand braces around commands, at least allow
   // the use of commands in a pipe.
-  STRCPY(buf, cmd);
+  strncpy(buf, cmd, len);
   if (itmp != NULL) {
     char_u  *p;
 
@@ -1362,55 +1364,56 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
     // Don't do this when 'shellquote' is not empty, otherwise the
     // redirection would be inside the quotes.
     if (*p_shq == NUL) {
-      p = vim_strchr(buf, '|');
-      if (p != NULL)
+      p = strchr(buf, '|');
+      if (p != NULL) {
         *p = NUL;
+      }
     }
-    STRCAT(buf, " < ");
-    STRCAT(buf, itmp);
+    strncat(buf, " < ", len);
+    strncat(buf, (char *) itmp, len);
     if (*p_shq == NUL) {
-      p = vim_strchr(cmd, '|');
+      p = strchr(cmd, '|');
       if (p != NULL) {
-        STRCAT(buf, " ");  // Insert a space before the '|' for DOS
-        STRCAT(buf, p);
+        strncat(buf, " ", len);  // Insert a space before the '|' for DOS
+        strncat(buf, p, len);
       }
     }
   }
 #endif
   if (otmp != NULL) {
-    append_redir(buf, len, p_srr, otmp);
+    append_redir(buf, len, (char *) p_srr, (char *) otmp);
   }
-  return buf;
+  return (char_u *) buf;
 }
 
-/*
- * Append output redirection for file "fname" to the end of string buffer
- * "buf[buflen]"
- * Works with the 'shellredir' and 'shellpipe' options.
- * The caller should make sure that there is enough room:
- *	STRLEN(opt) + STRLEN(fname) + 3
- */
-void append_redir(char_u *buf, size_t buflen, char_u *opt, char_u *fname)
+/// Append output redirection for the given file to the end of the buffer
+///
+/// @param[out]  buf  Buffer to append to.
+/// @param[in]  buflen  Buffer length.
+/// @param[in]  opt  Separator or format string to append: will append
+///                  `printf(' ' . opt, fname)` if `%s` is found in `opt` or
+///                  a space, opt, a space and then fname if `%s` is not found
+///                  there.
+/// @param[in]  fname  File name to append.
+void append_redir(char *const buf, const size_t buflen,
+                  const char *const opt, const char *const fname)
 {
-  char_u      *p;
-  char_u      *end;
-
-  end = buf + STRLEN(buf);
-  /* find "%s" */
-  for (p = opt; (p = vim_strchr(p, '%')) != NULL; ++p) {
-    if (p[1] == 's')     /* found %s */
+  char *const end = buf + strlen(buf);
+  // find "%s"
+  const char *p = opt;
+  for (; (p = strchr(p, '%')) != NULL; p++) {
+    if (p[1] == 's') {  // found %s
       break;
-    if (p[1] == '%')     /* skip %% */
-      ++p;
+    } else if (p[1] == '%') {  // skip %%
+      p++;
+    }
   }
   if (p != NULL) {
-    *end = ' ';     /* not really needed? Not with sh, ksh or bash */
-    vim_snprintf((char *)end + 1, (size_t)(buflen - (end + 1 - buf)),
-        (char *)opt, (char *)fname);
-  } else
-    vim_snprintf((char *)end, (size_t)(buflen - (end - buf)),
-        " %s %s",
-        (char *)opt, (char *)fname);
+    *end = ' ';  // not really needed? Not with sh, ksh or bash
+    vim_snprintf(end + 1, (size_t) (buflen - (end + 1 - buf)), opt, fname);
+  } else {
+    vim_snprintf(end, (size_t) (buflen - (end - buf)), " %s %s", opt, fname);
+  }
 }
 
 void print_line_no_prefix(linenr_T lnum, int use_number, int list)
@@ -2093,15 +2096,13 @@ do_ecmd (
 
   if ((command != NULL || newlnum > (linenr_T)0)
       && *get_vim_var_str(VV_SWAPCOMMAND) == NUL) {
-    char_u  *p;
-
-    /* Set v:swapcommand for the SwapExists autocommands. */
-    size_t len = (command != NULL) ? STRLEN(command) + 3 : 30;
-    p = xmalloc(len);
+    // Set v:swapcommand for the SwapExists autocommands.
+    const size_t len = (command != NULL) ? STRLEN(command) + 3 : 30;
+    char *const p = xmalloc(len);
     if (command != NULL) {
-      vim_snprintf((char *)p, len, ":%s\r", command);
+      vim_snprintf(p, len, ":%s\r", command);
     } else {
-      vim_snprintf((char *)p, len, "%" PRId64 "G", (int64_t)newlnum);
+      vim_snprintf(p, len, "%" PRId64 "G", (int64_t)newlnum);
     }
     set_vim_var_string(VV_SWAPCOMMAND, p, -1);
     did_set_swapcommand = TRUE;
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 71ea170e1c..2c8271c696 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -3168,27 +3168,27 @@ static char_u *get_mess_env(void)
  */
 void set_lang_var(void)
 {
-  char_u      *loc;
+  const char *loc;
 
 # ifdef HAVE_GET_LOCALE_VAL
-  loc = (char_u *)get_locale_val(LC_CTYPE);
+  loc = get_locale_val(LC_CTYPE);
 # else
-  /* setlocale() not supported: use the default value */
-  loc = (char_u *)"C";
+  // setlocale() not supported: use the default value
+  loc = "C";
 # endif
   set_vim_var_string(VV_CTYPE, loc, -1);
 
   /* When LC_MESSAGES isn't defined use the value from $LC_MESSAGES, fall
    * back to LC_CTYPE if it's empty. */
 # ifdef HAVE_WORKING_LIBINTL
-  loc = get_mess_env();
+  loc = (char *) get_mess_env();
 # else
-  loc = (char_u *)get_locale_val(LC_MESSAGES);
+  loc = get_locale_val(LC_MESSAGES);
 # endif
   set_vim_var_string(VV_LANG, loc, -1);
 
 # ifdef HAVE_GET_LOCALE_VAL
-  loc = (char_u *)get_locale_val(LC_TIME);
+  loc = get_locale_val(LC_TIME);
 # endif
   set_vim_var_string(VV_LC_TIME, loc, -1);
 }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index a7e98e7f04..6391e023c3 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -7421,10 +7421,10 @@ static int mksession_nl = FALSE;    /* use NL only in put_eol() */
 static void ex_mkrc(exarg_T *eap)
 {
   FILE        *fd;
-  int failed = FALSE;
-  int view_session = FALSE;
-  int using_vdir = FALSE;               /* using 'viewdir'? */
-  char_u      *viewFile = NULL;
+  int failed = false;
+  int view_session = false;
+  int using_vdir = false;  // using 'viewdir'?
+  char *viewFile = NULL;
   unsigned    *flagp;
 
   if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) {
@@ -7435,32 +7435,34 @@ static void ex_mkrc(exarg_T *eap)
    * short file name when 'acd' is set, that is checked later. */
   did_lcd = FALSE;
 
-  char_u *fname;
-  /* ":mkview" or ":mkview 9": generate file name with 'viewdir' */
+  char *fname;
+  // ":mkview" or ":mkview 9": generate file name with 'viewdir'
   if (eap->cmdidx == CMD_mkview
       && (*eap->arg == NUL
           || (ascii_isdigit(*eap->arg) && eap->arg[1] == NUL))) {
-    eap->forceit = TRUE;
-    fname = (char_u *)get_view_file(*eap->arg);
-    if (fname == NULL)
+    eap->forceit = true;
+    fname = get_view_file(*eap->arg);
+    if (fname == NULL) {
       return;
+    }
     viewFile = fname;
-    using_vdir = TRUE;
-  } else if (*eap->arg != NUL)
-    fname = eap->arg;
-  else if (eap->cmdidx == CMD_mkvimrc)
-    fname = (char_u *)VIMRC_FILE;
-  else if (eap->cmdidx == CMD_mksession)
-    fname = (char_u *)SESSION_FILE;
-  else
-    fname = (char_u *)EXRC_FILE;
+    using_vdir = true;
+  } else if (*eap->arg != NUL) {
+    fname = (char *) eap->arg;
+  } else if (eap->cmdidx == CMD_mkvimrc) {
+    fname = VIMRC_FILE;
+  } else if (eap->cmdidx == CMD_mksession) {
+    fname = SESSION_FILE;
+  } else {
+    fname = EXRC_FILE;
+  }
 
   /* When using 'viewdir' may have to create the directory. */
   if (using_vdir && !os_isdir(p_vdir)) {
     vim_mkdir_emsg(p_vdir, 0755);
   }
 
-  fd = open_exfile(fname, eap->forceit, WRITEBIN);
+  fd = open_exfile((char_u *) fname, eap->forceit, WRITEBIN);
   if (fd != NULL) {
     if (eap->cmdidx == CMD_mkview)
       flagp = &vop_flags;
@@ -7504,8 +7506,9 @@ static void ex_mkrc(exarg_T *eap)
             || os_chdir((char *)dirnow) != 0)
           *dirnow = NUL;
         if (*dirnow != NUL && (ssop_flags & SSOP_SESDIR)) {
-          if (vim_chdirfile(fname) == OK)
-            shorten_fnames(TRUE);
+          if (vim_chdirfile((char_u *) fname) == OK) {
+            shorten_fnames(true);
+          }
         } else if (*dirnow != NUL
                    && (ssop_flags & SSOP_CURDIR) && globaldir != NULL) {
           if (os_chdir((char *)globaldir) == 0)
@@ -7550,15 +7553,14 @@ static void ex_mkrc(exarg_T *eap)
 
     failed |= fclose(fd);
 
-    if (failed)
+    if (failed) {
       EMSG(_(e_write));
-    else if (eap->cmdidx == CMD_mksession) {
-      /* successful session write - set this_session var */
-      char_u      *tbuf;
-
-      tbuf = xmalloc(MAXPATHL);
-      if (vim_FullName((char *)fname, (char *)tbuf, MAXPATHL, FALSE) == OK)
+    } else if (eap->cmdidx == CMD_mksession) {
+      // successful session write - set this_session var
+      char *const tbuf = xmalloc(MAXPATHL);
+      if (vim_FullName(fname, tbuf, MAXPATHL, false) == OK) {
         set_vim_var_string(VV_THIS_SESSION, tbuf, -1);
+      }
       xfree(tbuf);
     }
 #ifdef MKSESSION_NL
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 6fc74c7ad0..41ad96a378 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -569,17 +569,19 @@ static void catch_exception(except_T *excp)
 {
   excp->caught = caught_stack;
   caught_stack = excp;
-  set_vim_var_string(VV_EXCEPTION, excp->value, -1);
+  set_vim_var_string(VV_EXCEPTION, (char *) excp->value, -1);
   if (*excp->throw_name != NUL) {
-    if (excp->throw_lnum != 0)
+    if (excp->throw_lnum != 0) {
       vim_snprintf((char *)IObuff, IOSIZE, _("%s, line %" PRId64),
-          excp->throw_name, (int64_t)excp->throw_lnum);
-    else
+                   excp->throw_name, (int64_t)excp->throw_lnum);
+    } else {
       vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name);
-    set_vim_var_string(VV_THROWPOINT, IObuff, -1);
-  } else
-    /* throw_name not set on an exception from a command that was typed. */
+    }
+    set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1);
+  } else {
+    // throw_name not set on an exception from a command that was typed.
     set_vim_var_string(VV_THROWPOINT, NULL, -1);
+  }
 
   if (p_verbose >= 13 || debug_break_level > 0) {
     int save_msg_silent = msg_silent;
@@ -614,20 +616,22 @@ static void finish_exception(except_T *excp)
     EMSG(_(e_internal));
   caught_stack = caught_stack->caught;
   if (caught_stack != NULL) {
-    set_vim_var_string(VV_EXCEPTION, caught_stack->value, -1);
+    set_vim_var_string(VV_EXCEPTION, (char *) caught_stack->value, -1);
     if (*caught_stack->throw_name != NUL) {
-      if (caught_stack->throw_lnum != 0)
+      if (caught_stack->throw_lnum != 0) {
         vim_snprintf((char *)IObuff, IOSIZE,
-            _("%s, line %" PRId64), caught_stack->throw_name,
-            (int64_t)caught_stack->throw_lnum);
-      else
+                     _("%s, line %" PRId64), caught_stack->throw_name,
+                     (int64_t)caught_stack->throw_lnum);
+      } else {
         vim_snprintf((char *)IObuff, IOSIZE, "%s",
-            caught_stack->throw_name);
-      set_vim_var_string(VV_THROWPOINT, IObuff, -1);
-    } else
-      /* throw_name not set on an exception from a command that was
-       * typed. */
+                     caught_stack->throw_name);
+      }
+      set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1);
+    } else {
+      // throw_name not set on an exception from a command that was
+      // typed.
       set_vim_var_string(VV_THROWPOINT, NULL, -1);
+    }
   } else {
     set_vim_var_string(VV_EXCEPTION, NULL, -1);
     set_vim_var_string(VV_THROWPOINT, NULL, -1);
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 383cd47dbe..f4fc744e04 100644
--- a/src/nvim/fileio.c
+++ b/