eval,*: Move get_tv_string to typval.c

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

1 files changed, 721 insertions, 711 deletions

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)
 {
-  char_u      *fname;
   char_u      *fresult = NULL;
   char_u      *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
   char_u      *p;
@@ -8287,7 +8304,7 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
   rettv->vval.v_string = NULL;
   rettv->v_type = VAR_STRING;
 
-  fname = get_tv_string(&argvars[0]);
+  const char *fname = tv_get_string(&argvars[0]);
 
   if (argvars[1].v_type != VAR_UNKNOWN) {
     p = get_tv_string_buf_chk(&argvars[1], pathbuf);
@@ -8311,8 +8328,8 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
     do {
       if (rettv->v_type == VAR_STRING || rettv->v_type == VAR_LIST)
         xfree(fresult);
-      fresult = find_file_in_path_option(first ? fname : NULL,
-                                         first ? STRLEN(fname) : 0,
+      fresult = find_file_in_path_option(first ? (char_u *)fname : NULL,
+                                         first ? strlen(fname) : 0,
                                          0, first, path,
                                          find_what, curbuf->b_ffname,
                                          (find_what == FINDFILE_DIR
@@ -8572,8 +8589,8 @@ static void f_fmod(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_fnameescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  rettv->vval.v_string = vim_strsave_fnameescape(
-      get_tv_string(&argvars[0]), FALSE);
+  rettv->vval.v_string = (char_u *)vim_strsave_fnameescape(
+      tv_get_string(&argvars[0]), false);
   rettv->v_type = VAR_STRING;
 }
 
@@ -8765,7 +8782,7 @@ static void common_function(typval_T *argvars, typval_T *rettv,
     s = partial_name(arg_pt);
   } else {
     // function('MyFunc', [arg], dict)
-    s = get_tv_string(&argvars[0]);
+    s = (char_u *)tv_get_string(&argvars[0]);
     use_string = true;
   }
 
@@ -8780,7 +8797,9 @@ static void common_function(typval_T *argvars, typval_T *rettv,
   }
   if (s == NULL || *s == NUL || (use_string && ascii_isdigit(*s))
       || (is_funcref && trans_name == NULL)) {
-    EMSG2(_(e_invarg2), use_string ? get_tv_string(&argvars[0]) : s);
+    emsgf(_(e_invarg2), (use_string
+                         ? tv_get_string(&argvars[0])
+                         : (const char *)s));
     // Don't check an autoload name for existence here.
   } else if (trans_name != NULL
              && (is_funcref ? find_func(trans_name) == NULL
@@ -8958,7 +8977,7 @@ static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   } else if (argvars[0].v_type == VAR_DICT) {
     if ((d = argvars[0].vval.v_dict) != NULL) {
-      di = tv_dict_find(d, (const char *)get_tv_string(&argvars[1]), -1);
+      di = tv_dict_find(d, tv_get_string(&argvars[1]), -1);
       if (di != NULL) {
         tv = &di->di_tv;
       }
@@ -8977,27 +8996,26 @@ static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
 
     if (pt != NULL) {
-      char_u *what = get_tv_string(&argvars[1]);
-      char_u *n;
+      const char *const what = tv_get_string(&argvars[1]);
 
-      if (STRCMP(what, "func") == 0 || STRCMP(what, "name") == 0) {
+      if (strcmp(what, "func") == 0 || strcmp(what, "name") == 0) {
         rettv->v_type = (*what == 'f' ? VAR_FUNC : VAR_STRING);
-        n = partial_name(pt);
+        const char *const n = (const char *)partial_name(pt);
         if (n == NULL) {
           rettv->vval.v_string = NULL;
         } else {
-          rettv->vval.v_string = vim_strsave(n);
+          rettv->vval.v_string = (char_u *)xstrdup(n);
           if (rettv->v_type == VAR_FUNC) {
             func_ref(rettv->vval.v_string);
           }
         }
-      } else if (STRCMP(what, "dict") == 0) {
+      } else if (strcmp(what, "dict") == 0) {
         rettv->v_type = VAR_DICT;
         rettv->vval.v_dict = pt->pt_dict;
         if (pt->pt_dict != NULL) {
           (pt->pt_dict->dv_refcount)++;
         }
-      } else if (STRCMP(what, "args") == 0) {
+      } else if (strcmp(what, "args") == 0) {
         rettv->v_type = VAR_LIST;
         if (tv_list_alloc_ret(rettv) != NULL) {
           for (int i = 0; i < pt->pt_argc; i++) {
@@ -9448,9 +9466,10 @@ static void f_getcompletion(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   ExpandInit(&xpc);
-  xpc.xp_pattern = get_tv_string(&argvars[0]);
+  xpc.xp_pattern = (char_u *)tv_get_string(&argvars[0]);
   xpc.xp_pattern_len = (int)STRLEN(xpc.xp_pattern);
-  xpc.xp_context = cmdcomplete_str_to_type(get_tv_string(&argvars[1]));
+  xpc.xp_context = cmdcomplete_str_to_type(
+      (char_u *)tv_get_string(&argvars[1]));
   if (xpc.xp_context == EXPAND_NOTHING) {
     EMSG2(_(e_invarg2), argvars[1].vval.v_string);
     return;
@@ -9623,20 +9642,21 @@ static void f_getfontname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *perm = NULL;
+  char *perm = NULL;
   char_u flags[] = "rwx";
 
-  char_u *filename = get_tv_string(&argvars[0]);
+  const char *filename = tv_get_string(&argvars[0]);
   int32_t file_perm = os_getperm(filename);
   if (file_perm >= 0) {
-    perm = vim_strsave((char_u *)"---------");
+    perm = xstrdup("---------");
     for (int i = 0; i < 9; i++) {
-      if (file_perm & (1 << (8 - i)))
+      if (file_perm & (1 << (8 - i))) {
         perm[i] = flags[i % 3];
+      }
     }
   }
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = perm;
+  rettv->vval.v_string = (char_u *)perm;
 }
 
 /*
@@ -9644,16 +9664,16 @@ static void f_getfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getfsize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char *fname = (char *)get_tv_string(&argvars[0]);
+  const char *fname = tv_get_string(&argvars[0]);
 
   rettv->v_type = VAR_NUMBER;
 
   FileInfo file_info;
   if (os_fileinfo(fname, &file_info)) {
     uint64_t filesize = os_fileinfo_size(&file_info);
-    if (os_isdir((char_u *)fname))
+    if (os_isdir((const char_u *)fname)) {
       rettv->vval.v_number = 0;
-    else {
+    } else {
       rettv->vval.v_number = (varnumber_T)filesize;
 
       /* non-perfect check for overflow */
@@ -9671,7 +9691,7 @@ static void f_getfsize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char *fname = (char *)get_tv_string(&argvars[0]);
+  const char *fname = tv_get_string(&argvars[0]);
 
   FileInfo file_info;
   if (os_fileinfo(fname, &file_info)) {
@@ -9686,15 +9706,14 @@ static void f_getftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getftype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *fname;
   char_u      *type = NULL;
   char        *t;
 
-  fname = get_tv_string(&argvars[0]);
+  const char *fname = tv_get_string(&argvars[0]);
 
   rettv->v_type = VAR_STRING;
   FileInfo file_info;
-  if (os_fileinfo_link((char *)fname, &file_info)) {
+  if (os_fileinfo_link(fname, &file_info)) {
     uint64_t mode = file_info.stat.st_mode;
 #ifdef S_ISREG
     if (S_ISREG(mode))
@@ -9746,10 +9765,11 @@ static void f_getftype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     default: t = "other";
     }
 # else
-    if (os_isdir(fname))
+    if (os_isdir((const char_u *)fname)) {
       t = "dir";
-    else
+    } else {
       t = "file";
+    }
 # endif
 #endif
     type = vim_strsave((char_u *)t);
@@ -10345,11 +10365,12 @@ static void f_glob(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     if (p_wic)
       options += WILD_ICASE;
     if (rettv->v_type == VAR_STRING) {
-      rettv->vval.v_string = ExpandOne(&xpc, get_tv_string(&argvars[0]), NULL,
-                                       options, WILD_ALL);
+      rettv->vval.v_string = ExpandOne(
+          &xpc, (char_u *)tv_get_string(&argvars[0]), NULL, options, WILD_ALL);
     } else {
       tv_list_alloc_ret(rettv);
-      ExpandOne(&xpc, get_tv_string(&argvars[0]), NULL, options, WILD_ALL_KEEP);
+      ExpandOne(&xpc, (char_u *)tv_get_string(&argvars[0]), 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);
@@ -10393,7 +10414,7 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (file != NULL && !error) {
     garray_T ga;
     ga_init(&ga, (int)sizeof(char_u *), 10);
-    globpath(get_tv_string(&argvars[0]), file, &ga, flags);
+    globpath((char_u *)tv_get_string(&argvars[0]), file, &ga, flags);
 
     if (rettv->v_type == VAR_STRING) {
       rettv->vval.v_string = ga_concat_strings_sep(&ga, "\n");
@@ -10425,7 +10446,7 @@ static void f_glob2regpat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "has()" function
 static void f_has(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  static char *(has_list[]) = {
+  static const char *const has_list[] = {
 #ifdef UNIX
     "unix",
 #endif
@@ -10536,13 +10557,11 @@ static void f_has(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     "winaltkeys",
     "writebackup",
     "nvim",
-    NULL
   };
 
   bool n = false;
-  char *name = (char *)get_tv_string(&argvars[0]);
-
-  for (int i = 0; has_list[i] != NULL; i++) {
+  const char *const name = tv_get_string(&argvars[0]);
+  for (size_t i = 0; i < ARRAY_SIZE(has_list); i++) {
     if (STRICMP(name, has_list[i]) == 0) {
       n = true;
       break;
@@ -10608,7 +10627,7 @@ static void f_has_key(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     return;
 
   rettv->vval.v_number = tv_dict_find(argvars[0].vval.v_dict,
-                                      (const char *)get_tv_s