eval,*: Move get_tv_string to typval.c

Function was renamed and changed to return `const char *`.

28 files changed, 1072 insertions, 992 deletions

diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index 6b17ba1a11..2c8a56cc1a 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -625,7 +625,7 @@ String cstr_as_string(char *str) FUNC_ATTR_PURE
   if (str == NULL) {
     return (String) STRING_INIT;
   }
-  return (String) {.data = str, .size = strlen(str)};
+  return (String) { .data = str, .size = strlen(str) };
 }
 
 /// Converts from type Object to a VimL value.
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 0ce9ce073e..0fb9a21354 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -4207,11 +4207,11 @@ void fname_expand(buf_T *buf, char_u **ffname, char_u **sfname)
 #ifdef WIN32
   if (!buf->b_p_bin) {
     // If the file name is a shortcut file, use the file it links to.
-    char_u *rfname = (char_u *)os_resolve_shortcut(*ffname);
+    char *rfname = os_resolve_shortcut((const char *)(*ffname));
     if (rfname != NULL) {
       xfree(*ffname);
-      *ffname = rfname;
-      *sfname = rfname;
+      *ffname = (char_u *)rfname;
+      *sfname = (char_u *)rfname;
     }
   }
 #endif
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index d1cceb435a..b396251051 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -3464,7 +3464,6 @@ expand_by_function (
 {
   list_T      *matchlist = NULL;
   dict_T      *matchdict = NULL;
-  char_u      *args[2];
   char_u      *funcname;
   pos_T pos;
   win_T       *curwin_save;
@@ -3475,9 +3474,8 @@ expand_by_function (
   if (*funcname == NUL)
     return;
 
-  /* Call 'completefunc' to obtain the list of matches. */
-  args[0] = (char_u *)"0";
-  args[1] = base;
+  // Call 'completefunc' to obtain the list of matches.
+  const char_u *const args[2] = { (char_u *)"0", base };
 
   pos = curwin->w_cursor;
   curwin_save = curwin;
@@ -4589,7 +4587,6 @@ static int ins_complete(int c, bool enable_pum)
        * Call user defined function 'completefunc' with "a:findstart"
        * set to 1 to obtain the length of text to use for completion.
        */
-      char_u      *args[2];
       int col;
       char_u      *funcname;
       pos_T pos;
@@ -4608,8 +4605,7 @@ static int ins_complete(int c, bool enable_pum)
         return FAIL;
       }
 
-      args[0] = (char_u *)"1";
-      args[1] = NULL;
+      const char_u *const args[2] = { (char_u *)"1", NULL };
       pos = curwin->w_cursor;
       curwin_save = curwin;
       curbuf_save = curbuf;
@@ -7111,8 +7107,8 @@ static void ins_ctrl_g(void)
  */
 static void ins_ctrl_hat(void)
 {
-  if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE)) {
-    /* ":lmap" mappings exists, Toggle use of ":lmap" mappings. */
+  if (map_to_exists_mode("", LANGMAP, false)) {
+    // ":lmap" mappings exists, Toggle use of ":lmap" mappings.
     if (State & LANGMAP) {
       curbuf->b_p_iminsert = B_IMODE_NONE;
       State &= ~LANGMAP;
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 1d060eff33..7e40f5e828 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -965,31 +965,34 @@ eval_to_bool (
   return retval;
 }
 
-/*
- * Top level evaluation function, returning a string.  If "skip" is TRUE,
- * only parsing to "nextcmd" is done, without reporting errors.  Return
- * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
- */
-char_u *
-eval_to_string_skip (
-    char_u *arg,
-    char_u **nextcmd,
-    int skip                   /* only parse, don't execute */
-)
+/// Top level evaluation function, returning a string
+///
+/// @param[in]  arg  String to evaluate.
+/// @param  nextcmd  Pointer to the start of the next Ex command.
+/// @param[in]  skip  If true, only do parsing to nextcmd without reporting
+///                   errors or actually evaluating anything.
+///
+/// @return [allocated] string result of evaluation or NULL in case of error or
+///                     when skipping.
+char *eval_to_string_skip(const char *arg, const char **nextcmd,
+                          const bool skip)
+  FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_WARN_UNUSED_RESULT
 {
   typval_T tv;
-  char_u      *retval;
+  char *retval;
 
-  if (skip)
-    ++emsg_skip;
-  if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip)
+  if (skip) {
+    emsg_skip++;
+  }
+  if (eval0((char_u *)arg, &tv, (char_u **)nextcmd, !skip) == FAIL || skip) {
     retval = NULL;
-  else {
-    retval = vim_strsave(get_tv_string(&tv));
+  } else {
+    retval = xstrdup(tv_get_string(&tv));
     tv_clear(&tv);
   }
-  if (skip)
-    --emsg_skip;
+  if (skip) {
+    emsg_skip--;
+  }
 
   return retval;
 }
@@ -1015,13 +1018,12 @@ int skip_expr(char_u **pp)
 char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert)
 {
   typval_T tv;
-  char_u      *retval;
+  char *retval;
   garray_T ga;
-  char_u numbuf[NUMBUFLEN];
 
-  if (eval0(arg, &tv, nextcmd, TRUE) == FAIL)
+  if (eval0(arg, &tv, nextcmd, true) == FAIL) {
     retval = NULL;
-  else {
+  } else {
     if (convert && tv.v_type == VAR_LIST) {
       ga_init(&ga, (int)sizeof(char), 80);
       if (tv.vval.v_list != NULL) {
@@ -1031,16 +1033,18 @@ char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert)
         }
       }
       ga_append(&ga, NUL);
-      retval = (char_u *)ga.ga_data;
+      retval = (char *)ga.ga_data;
     } else if (convert && tv.v_type == VAR_FLOAT) {
-      vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float);
-      retval = vim_strsave(numbuf);
-    } else
-      retval = vim_strsave(get_tv_string(&tv));
+      char numbuf[NUMBUFLEN];
+      vim_snprintf(numbuf, NUMBUFLEN, "%g", tv.vval.v_float);
+      retval = xstrdup(numbuf);
+    } else {
+      retval = xstrdup(tv_get_string(&tv));
+    }
     tv_clear(&tv);
   }
 
-  return retval;
+  return (char_u *)retval;
 }
 
 /*
@@ -1159,14 +1163,15 @@ list_T *eval_spell_expr(char_u *badword, char_u *expr)
  * Return -1 if anything isn't right.
  * Used to get the good word and score from the eval_spell_expr() result.
  */
-int get_spellword(list_T *list, char_u **pp)
+int get_spellword(list_T *list, const char **pp)
 {
   listitem_T  *li;
 
   li = list->lv_first;
-  if (li == NULL)
+  if (li == NULL) {
     return -1;
-  *pp = get_tv_string(&li->li_tv);
+  }
+  *pp = tv_get_string(&li->li_tv);
 
   li = li->li_next;
   if (li == NULL)
@@ -1198,9 +1203,9 @@ typval_T *eval_expr(char_u *arg, char_u **nextcmd)
 //
 // Return OK or FAIL.
 int call_vim_function(
-    char_u *func,
+    const char_u *func,
     int argc,
-    char_u **argv,
+    const char_u *const *const argv,
     int safe,                       // use the sandbox
     int str_arg_only,               // all arguments are strings
     typval_T *rettv
@@ -1233,7 +1238,7 @@ int call_vim_function(
       argvars[i].vval.v_number = n;
     } else {
       argvars[i].v_type = VAR_STRING;
-      argvars[i].vval.v_string = argv[i];
+      argvars[i].vval.v_string = (char_u *)argv[i];
     }
   }
 
@@ -1268,8 +1273,8 @@ long
 call_func_retnr (
     char_u *func,
     int argc,
-    char_u **argv,
-    int safe                       /* use the sandbox */
+    const char_u *const *const argv,
+    int safe                       // use the sandbox
 )
 {
   typval_T rettv;
@@ -1284,27 +1289,28 @@ call_func_retnr (
   return retval;
 }
 
-/*
- * Call vimL function "func" and return the result as a string.
- * Returns NULL when calling the function fails.
- * Uses argv[argc] for the function arguments.
- */
-void *
-call_func_retstr (
-    char_u *func,
-    int argc,
-    char_u **argv,
-    int safe                       /* use the sandbox */
-)
+/// Call VimL function and return the result as a string
+///
+/// @param[in]  func  Function name.
+/// @param[in]  argc  Number of arguments.
+/// @param[in]  argv  Array with string arguments.
+/// @param[in]  safe  Use the sandbox.
+///
+/// @return [allocated] NULL when calling function failes, allocated string
+///                     otherwise.
+char *call_func_retstr(const char *const func, const int argc,
+                       const char_u *const *const argv,
+                       const bool safe)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC
 {
   typval_T rettv;
-  char_u      *retval;
-
-  /* All arguments are passed as strings, no conversion to number. */
-  if (call_vim_function(func, argc, argv, safe, TRUE, &rettv) == FAIL)
+  // All arguments are passed as strings, no conversion to number.
+  if (call_vim_function((const char_u *)func, argc, argv, safe, true, &rettv)
+      == FAIL) {
     return NULL;
+  }
 
-  retval = vim_strsave(get_tv_string(&rettv));
+  char *const retval = xstrdup(tv_get_string(&rettv));
   tv_clear(&rettv);
   return retval;
 }
@@ -1318,8 +1324,8 @@ void *
 call_func_retlist (
     char_u *func,
     int argc,
-    char_u **argv,
-    int safe                       /* use the sandbox */
+    const char_u *const *const argv,
+    int safe                       // use the sandbox
 )
 {
   typval_T rettv;
@@ -2202,7 +2208,7 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
     if (lp->ll_tv->v_type == VAR_DICT) {
       if (len == -1) {
         // "[key]": get key from "var1"
-        key = get_tv_string_chk(&var1);  // is number or string
+        key = (char_u *)tv_get_string(&var1);  // is number or string
         if (key == NULL) {
           tv_clear(&var1);
           return NULL;
@@ -4343,9 +4349,8 @@ eval_index (
   bool empty1 = false;
   bool empty2 = false;
   long n1, n2 = 0;
-  long len = -1;
+  ptrdiff_t len = -1;
   int range = false;
-  char_u      *s;
   char_u      *key = NULL;
 
   switch (rettv->v_type) {
@@ -4455,103 +4460,109 @@ eval_index (
       tv_clear(&var1);
     }
     if (range) {
-      if (empty2)
+      if (empty2) {
         n2 = -1;
-      else {
+      } else {
         n2 = get_tv_number(&var2);
         tv_clear(&var2);
       }
     }
 
     switch (rettv->v_type) {
-    case VAR_NUMBER:
-    case VAR_STRING:
-      s = get_tv_string(rettv);
-      len = (long)STRLEN(s);
-      if (range) {
-        /* The resulting variable is a substring.  If the indexes
-         * are out of range the result is empty. */
+      case VAR_NUMBER:
+      case VAR_STRING: {
+        const char *const s = tv_get_string(rettv);
+        char *v;
+        len = (ptrdiff_t)strlen(s);
+        if (range) {
+          // The resulting variable is a substring.  If the indexes
+          // are out of range the result is empty.
+          if (n1 < 0) {
+            n1 = len + n1;
+            if (n1 < 0) {
+              n1 = 0;
+            }
+          }
+          if (n2 < 0) {
+            n2 = len + n2;
+          } else if (n2 >= len) {
+            n2 = len;
+          }
+          if (n1 >= len || n2 < 0 || n1 > n2) {
+            v = NULL;
+          } else {
+            v = xmemdupz(s + n1, (size_t)(n2 - n1 + 1));
+          }
+        } else {
+          // The resulting variable is a string of a single
+          // character.  If the index is too big or negative the
+          // result is empty.
+          if (n1 >= len || n1 < 0) {
+            v = NULL;
+          } else {
+            v = xmemdupz(s + n1, 1);
+          }
+        }
+        tv_clear(rettv);
+        rettv->v_type = VAR_STRING;
+        rettv->vval.v_string = (char_u *)v;
+        break;
+      }
+      case VAR_LIST: {
+        len = tv_list_len(rettv->vval.v_list);
         if (n1 < 0) {
           n1 = len + n1;
-          if (n1 < 0)
-            n1 = 0;
         }
-        if (n2 < 0)
-          n2 = len + n2;
-        else if (n2 >= len)
-          n2 = len;
-        if (n1 >= len || n2 < 0 || n1 > n2)
-          s = NULL;
-        else
-          s = vim_strnsave(s + n1, (int)(n2 - n1 + 1));
-      } else {
-        /* The resulting variable is a string of a single
-         * character.  If the index is too big or negative the
-         * result is empty. */
-        if (n1 >= len || n1 < 0)
-          s = NULL;
-        else
-          s = vim_strnsave(s + n1, 1);
-      }
-      tv_clear(rettv);
-      rettv->v_type = VAR_STRING;
-      rettv->vval.v_string = s;
-      break;
-
-    case VAR_LIST:
-      len = tv_list_len(rettv->vval.v_list);
-      if (n1 < 0) {
-        n1 = len + n1;
-      }
-      if (!empty1 && (n1 < 0 || n1 >= len)) {
-        /* For a range we allow invalid values and return an empty
-         * list.  A list index out of range is an error. */
-        if (!range) {
-          if (verbose)
-            EMSGN(_(e_listidx), n1);
-          return FAIL;
+        if (!empty1 && (n1 < 0 || n1 >= len)) {
+          // For a range we allow invalid values and return an empty
+          // list.  A list index out of range is an error.
+          if (!range) {
+            if (verbose) {
+              EMSGN(_(e_listidx), n1);
+            }
+            return FAIL;
+          }
+          n1 = len;
         }
-        n1 = len;
-      }
-      if (range) {
-        list_T      *l;
-        listitem_T  *item;
-
-        if (n2 < 0)
-          n2 = len + n2;
-        else if (n2 >= len)
-          n2 = len - 1;
-        if (!empty2 && (n2 < 0 || n2 + 1 < n1))
-          n2 = -1;
-        l = tv_list_alloc();
-        item = tv_list_find(rettv->vval.v_list, n1);
-        while (n1++ <= n2) {
-          tv_list_append_tv(l, &item->li_tv);
-          item = item->li_next;
+        if (range) {
+          list_T      *l;
+          listitem_T  *item;
+
+          if (n2 < 0) {
+            n2 = len + n2;
+          } else if (n2 >= len) {
+            n2 = len - 1;
+          }
+          if (!empty2 && (n2 < 0 || n2 + 1 < n1)) {
+            n2 = -1;
+          }
+          l = tv_list_alloc();
+          item = tv_list_find(rettv->vval.v_list, n1);
+          while (n1++ <= n2) {
+            tv_list_append_tv(l, &item->li_tv);
+            item = item->li_next;
+          }
+          tv_clear(rettv);
+          rettv->v_type = VAR_LIST;
+          rettv->vval.v_list = l;
+          l->lv_refcount++;
+        } else {
+          copy_tv(&tv_list_find(rettv->vval.v_list, n1)->li_tv, &var1);
+          tv_clear(rettv);
+          *rettv = var1;
         }
-        tv_clear(rettv);
-        rettv->v_type = VAR_LIST;
-        rettv->vval.v_list = l;
-        ++l->lv_refcount;
-      } else {
-        copy_tv(&tv_list_find(rettv->vval.v_list, n1)->li_tv, &var1);
-        tv_clear(rettv);
-        *rettv = var1;
+        break;
       }
-      break;
-
-    case VAR_DICT:
-      if (range) {
-        if (verbose) {
-          emsgf(_(e_dictrange));
-        }
-        if (len == -1) {
-          tv_clear(&var1);
+      case VAR_DICT: {
+        if (range) {
+          if (verbose) {
+            emsgf(_(e_dictrange));
+          }
+          if (len == -1) {
+            tv_clear(&var1);
+          }
+          return FAIL;
         }
-        return FAIL;
-      }
-      {
-        dictitem_T  *item;
 
         if (len == -1) {
           key = get_tv_string_chk(&var1);
@@ -4561,7 +4572,8 @@ eval_index (
           }
         }
 
-        item = tv_dict_find(rettv->vval.v_dict, (const char *)key, len);
+        dictitem_T *const item = tv_dict_find(rettv->vval.v_dict,
+                                              (const char *)key, len);
 
         if (item == NULL && verbose) {
           emsgf(_(e_dictkey), key);
@@ -4576,14 +4588,15 @@ eval_index (
         copy_tv(&item->di_tv, &var1);
         tv_clear(rettv);
         *rettv = var1;
+        break;
+      }
+      case VAR_SPECIAL:
+      case VAR_FUNC:
+      case VAR_FLOAT:
+      case VAR_PARTIAL:
+      case VAR_UNKNOWN: {
+        break;  // Not evaluating, skipping over subscript
       }
-      break;
-    case VAR_SPECIAL:
-    case VAR_FUNC:
-    case VAR_PARTIAL:
-    case VAR_FLOAT:
-    case VAR_UNKNOWN:
-      break;  // Not evaluating, skipping over subscript
     }
   }
 
@@ -6251,7 +6264,7 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
 /// Also returns OK when an error was encountered while executing the function.
 int
 call_func(
-    char_u *funcname,               // name of the function
+    const char_u *funcname,         // name of the function
     int len,                        // length of "name"
     typval_T *rettv,                // return value goes here
     int argcount_in,                // number of "argvars"
@@ -7249,24 +7262,24 @@ int func_call(char_u *name, typval_T *args, partial_T *partial,
 /// "call(func, arglist [, dict])" function
 static void f_call(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *func;
-  partial_T   *partial = NULL;
-  dict_T      *selfdict = NULL;
-
   if (argvars[1].v_type != VAR_LIST) {
     EMSG(_(e_listreq));
     return;
   }
-  if (argvars[1].vval.v_list == NULL)
+  if (argvars[1].vval.v_list == NULL) {
     return;
+  }
 
+  char_u      *func;
+  partial_T   *partial = NULL;
+  dict_T      *selfdict = NULL;
   if (argvars[0].v_type == VAR_FUNC) {
     func = argvars[0].vval.v_string;
   } else if (argvars[0].v_type == VAR_PARTIAL) {
     partial = argvars[0].vval.v_partial;
     func = partial_name(partial);
   } else {
-    func = get_tv_string(&argvars[0]);
+    func = (char_u *)tv_get_string(&argvars[0]);
   }
   if (*func == NUL) {
     return;             // type error or empty name
@@ -7299,15 +7312,15 @@ static void f_char2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (has_mbyte) {
     int utf8 = 0;
 
-    if (argvars[1].v_type != VAR_UNKNOWN)
+    if (argvars[1].v_type != VAR_UNKNOWN) {
       utf8 = get_tv_number_chk(&argvars[1], NULL);
+    }
 
-    if (utf8)
-      rettv->vval.v_number = (*utf_ptr2char)(get_tv_string(&argvars[0]));
-    else
-      rettv->vval.v_number = (*mb_ptr2char)(get_tv_string(&argvars[0]));
-  } else
-    rettv->vval.v_number = get_tv_string(&argvars[0])[0];
+    rettv->vval.v_number = (utf8 ? *utf_ptr2char : *mb_ptr2char)(
+        (const char_u *)tv_get_string(&argvars[0]));
+  } else {
+    rettv->vval.v_number = (uint8_t)(tv_get_string(&argvars[0])[0]);
+  }
 }
 
 /*
@@ -7552,16 +7565,17 @@ static void f_count(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_cscope_connection(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int num = 0;
-  char_u      *dbpath = NULL;
-  char_u      *prepend = NULL;
+  char_u *dbpath = NULL;
+  char_u *prepend = NULL;
   char_u buf[NUMBUFLEN];
 
   if (argvars[0].v_type != VAR_UNKNOWN
       && argvars[1].v_type != VAR_UNKNOWN) {
     num = (int)get_tv_number(&argvars[0]);
-    dbpath = get_tv_string(&argvars[1]);
-    if (argvars[2].v_type != VAR_UNKNOWN)
+    dbpath = (char_u *)tv_get_string(&argvars[1]);
+    if (argvars[2].v_type != VAR_UNKNOWN) {
       prepend = get_tv_string_buf(&argvars[2], buf);
+    }
   }
 
   rettv->vval.v_number = cs_connection(num, dbpath, prepend);
@@ -7648,7 +7662,6 @@ static void f_deepcopy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_delete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   char_u nbuf[NUMBUFLEN];
-  char_u *name;
   char_u *flags;
 
   rettv->vval.v_number = -1;
@@ -7656,7 +7669,7 @@ static void f_delete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     return;
   }
 
-  name = get_tv_string(&argvars[0]);
+  const char *const name = tv_get_string(&argvars[0]);
   if (name == NULL || *name == NUL) {
     EMSG(_(e_invarg));
     return;
@@ -7670,10 +7683,10 @@ static void f_delete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   if (*flags == NUL) {
     // delete a file
-    rettv->vval.v_number = os_remove((char *)name) == 0 ? 0 : -1;
+    rettv->vval.v_number = os_remove(name) == 0 ? 0 : -1;
   } else if (STRCMP(flags, "d") == 0) {
     // delete an empty directory
-    rettv->vval.v_number = os_rmdir((char *)name) == 0 ? 0 : -1;
+    rettv->vval.v_number = os_rmdir(name) == 0 ? 0 : -1;
   } else if (STRCMP(flags, "rf") == 0) {
     // delete a directory recursively
     rettv->vval.v_number = delete_recursive(name);
@@ -7894,7 +7907,8 @@ static void f_escape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   char_u buf[NUMBUFLEN];
 
-  rettv->vval.v_string = vim_strsave_escaped(get_tv_string(&argvars[0]),
+  rettv->vval.v_string = vim_strsave_escaped(
+      (const char_u *)tv_get_string(&argvars[0]),
       get_tv_string_buf(&argvars[1], buf));
   rettv->v_type = VAR_STRING;
 }
@@ -7936,11 +7950,13 @@ static void f_eventhandler(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_executable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *name = get_tv_string(&argvars[0]);
+  const char *name = tv_get_string(&argvars[0]);
 
   // Check in $PATH and also check directly if there is a directory name
-  rettv->vval.v_number = os_can_exe(name, NULL, true)
-           || (gettail_dir(name) != name && os_can_exe(name, NULL, false));
+  rettv->vval.v_number = (
+      os_can_exe((const char_u *)name, NULL, true)
+      || (gettail_dir(name) != name
+          && os_can_exe((const char_u *)name, NULL, false)));
 }
 
 static char_u * get_list_line(int c, void *cookie, int indent)
@@ -7993,11 +8009,11 @@ static void f_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     capture_ga = &capture_local;
 
     if (argvars[0].v_type != VAR_LIST) {
-      do_cmdline_cmd((char *)get_tv_string(&argvars[0]));
+      do_cmdline_cmd(tv_get_string(&argvars[0]));
     } else if (argvars[0].vval.v_list != NULL) {
-      list_T *list = argvars[0].vval.v_list;
+      list_T *const list = argvars[0].vval.v_list;
       list->lv_refcount++;
-      listitem_T *item = list->lv_first;
+      listitem_T *const item = list->lv_first;
       do_cmdline(NULL, get_list_line, (void *)&item,
                  DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT|DOCMD_KEYTYPED);
       list->lv_refcount--;
@@ -8017,10 +8033,10 @@ static void f_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "exepath()" function
 static void f_exepath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *arg = get_tv_string(&argvars[0]);
+  const char *arg = tv_get_string(&argvars[0]);
   char_u *path = NULL;
 
-  (void)os_can_exe(arg, &path, true);
+  (void)os_can_exe((const char_u *)arg, &path, true);
 
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = path;
@@ -8034,21 +8050,21 @@ static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   int n = false;
   int len = 0;
 
-  char *p = (char *)get_tv_string(&argvars[0]);
+  const char *p = tv_get_string(&argvars[0]);
   if (*p == '$') {  // Environment variable.
     // First try "normal" environment variables (fast).
     if (os_getenv(p + 1) != NULL) {
       n = true;
     } else {
       // Try expanding things like $VIM and ${HOME}.
-      p = (char *)expand_env_save((char_u *)p);
-      if (p != NULL && *p != '$') {
+      char_u *const exp = expand_env_save((char_u *)p);
+      if (exp != NULL && *exp != '$') {
         n = true;
       }
-      xfree(p);
+      xfree(exp);
     }
   } else if (*p == '&' || *p == '+') {  // Option.
-    n = (get_option_tv((const char **)&p, NULL, true) == OK);
+    n = (get_option_tv(&p, NULL, true) == OK);
     if (*skipwhite((const char_u *)p) != NUL) {
       n = false;  // Trailing garbage.
     }
@@ -8076,7 +8092,7 @@ static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       n = (get_var_tv(name, len, &tv, NULL, false, true) == OK);
       if (n) {
         // Handle d.key, l[idx], f(expr).
-        n = (handle_subscript((const char **)&p, &tv, true, false) == OK);
+        n = (handle_subscript(&p, &tv, true, false) == OK);
         if (n) {
           tv_clear(&tv);
         }
@@ -8096,7 +8112,6 @@ static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *s;
   size_t len;
   char_u      *errormsg;
   int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
@@ -8113,11 +8128,11 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     rettv->vval.v_list = NULL;
   }
 
-  s = get_tv_string(&argvars[0]);
+  const char *s = tv_get_string(&argvars[0]);
   if (*s == '%' || *s == '#' || *s == '<') {
-    ++emsg_off;
-    result = eval_vars(s, s, &len, NULL, &errormsg, NULL);
-    --emsg_off;
+    emsg_off++;
+    result = eval_vars((char_u *)s, (char_u *)s, &len, NULL, &errormsg, NULL);
+    emsg_off--;
     if (rettv->v_type == VAR_LIST) {
       tv_list_alloc_ret(rettv);
       if (result != NULL) {
@@ -8134,21 +8149,24 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     if (!error) {
       ExpandInit(&xpc);
       xpc.xp_context = EXPAND_FILES;
-      if (p_wic)
+      if (p_wic) {
         options += WILD_ICASE;
+      }
       if (rettv->v_type == VAR_STRING) {
-        rettv->vval.v_string = ExpandOne(&xpc, s, NULL, options, WILD_ALL);
+        rettv->vval.v_string = ExpandOne(&xpc, (char_u *)s, NULL, options,
+                                         WILD_ALL);
       } else {
         tv_list_alloc_ret(rettv);
-        ExpandOne(&xpc, s, NULL, options, WILD_ALL_KEEP);
+        ExpandOne(&xpc, (char_u *)s, NULL, options, WILD_ALL_KEEP);
         for (int i = 0; i < xpc.xp_numfiles; i++) {
           tv_list_append_string(rettv->vval.v_list,
                                 (const char *)xpc.xp_files[i], -1);
         }
         ExpandCleanup(&xpc);
       }
-    } else
+    } else {
       rettv->vval.v_string = NULL;
+    }
   }
 }
 
@@ -8235,7 +8253,6 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_feedkeys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *keys, *flags = NULL;
   char_u nbuf[NUMBUFLEN];
 
   /* This is not allowed in the sandbox.  If the commands would still be
@@ -8244,10 +8261,11 @@ static void f_feedkeys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (check_secure())
     return;
 
-  keys = get_tv_string(&argvars[0]);
+  const char *const keys = tv_get_string(&argvars[0]);
 
+  const char *flags = NULL;
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    flags = get_tv_string_buf(&argvars[1], nbuf);
+    flags = (const char *)get_tv_string_buf(&argvars[1], nbuf);
   }
 
   nvim_feedkeys(cstr_as_string((char *)keys),
@@ -8257,9 +8275,9 @@ static void f_feedkeys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "filereadable()" function
 static void f_filereadable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *p = get_tv_string(&argvars[0]);
+  const char *const p = tv_get_string(&argvars[0]);
   rettv->vval.v_number =
-    (*p && !os_isdir(p) && os_file_is_readable((char*)p));
+    (*p && !os_isdir((const char_u *)p) && os_file_is_readable(p));
 }
 
 /*
@@ -8268,14 +8286,13 @@ static void f_filereadable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_filewritable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char *filename = (char *)get_tv_string(&argvars[0]);
+  const char *filename = tv_get_string(&argvars[0]);
   rettv->vval.v_number = os_file_is_writable(filename);
 }
 
 
 static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)