eval: Move remaining get_tv_string* functions to eval/typval.c

1 files changed, 617 insertions, 663 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 65bb90fc15..3a0075e48a 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -173,7 +173,6 @@ static char *e_funcref = N_("E718: Funcref required");
 static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
 static char *e_nofunc = N_("E130: Unknown function: %s");
 static char *e_illvar = N_("E461: Illegal variable name: %s");
-static char *e_float_as_string = N_("E806: using Float as a String");
 static const char *e_readonlyvar = N_(
     "E46: Cannot change read-only variable \"%.*s\"");
 
@@ -1852,7 +1851,6 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
                           const char_u *const op)
   FUNC_ATTR_NONNULL_ARG(1, 2) FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  char_u *name;
   char_u *arg_end = NULL;
   int len;
   int opt_flags;
@@ -1864,7 +1862,7 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
   if (*arg == '$') {
     // Find the end of the name.
     arg++;
-    name = arg;
+    char *name = (char *)arg;
     len = get_env_len((const char_u **)&arg);
     if (len == 0) {
       EMSG2(_(e_invarg2), name - 1);
@@ -1875,26 +1873,28 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
                  && vim_strchr(endchars, *skipwhite(arg)) == NULL) {
         EMSG(_(e_letunexp));
       } else if (!check_secure()) {
-        const char_u c1 = name[len];
+        const char c1 = name[len];
         name[len] = NUL;
-        char_u *p = get_tv_string_chk(tv);
+        const char *p = tv_get_string_chk(tv);
         if (p != NULL && op != NULL && *op == '.') {
-          char *s = vim_getenv((char *)name);
+          char *s = vim_getenv(name);
 
           if (s != NULL) {
-            p = tofree = concat_str((char_u *)s, p);
+            tofree = concat_str((const char_u *)s, (const char_u *)p);
+            p = (const char *)tofree;
             xfree(s);
           }
         }
         if (p != NULL) {
-          vim_setenv((char *)name, (char *)p);
-          if (STRICMP(name, "HOME") == 0)
+          vim_setenv(name, p);
+          if (STRICMP(name, "HOME") == 0) {
             init_homedir();
-          else if (didset_vim && STRICMP(name, "VIM") == 0)
-            didset_vim = FALSE;
-          else if (didset_vimruntime
-                   && STRICMP(name, "VIMRUNTIME") == 0)
-            didset_vimruntime = FALSE;
+          } else if (didset_vim && STRICMP(name, "VIM") == 0) {
+            didset_vim = false;
+          } else if (didset_vimruntime
+                     && STRICMP(name, "VIMRUNTIME") == 0) {
+            didset_vimruntime = false;
+          }
           arg_end = arg;
         }
         name[len] = c1;
@@ -1914,16 +1914,16 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
     } else {
       int opt_type;
       long numval;
-      char_u *stringval = NULL;
-      char_u *s;
+      char *stringval = NULL;
 
       const char c1 = *p;
       *p = NUL;
 
       varnumber_T n = tv_get_number(tv);
-      s = get_tv_string_chk(tv);  // != NULL if number or string.
+      const char *s = tv_get_string_chk(tv);  // != NULL if number or string.
       if (s != NULL && op != NULL && *op != '=') {
-        opt_type = get_option_value(arg, &numval, &stringval, opt_flags);
+        opt_type = get_option_value(arg, &numval, (char_u **)&stringval,
+                                    opt_flags);
         if ((opt_type == 1 && *op == '.')
             || (opt_type == 0 && *op != '.')) {
           EMSG2(_(e_letwrong), op);
@@ -1935,44 +1935,45 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
               n = numval - n;
             }
           } else if (opt_type == 0 && stringval != NULL) {  // string
-            s = concat_str(stringval, s);
-            xfree(stringval);
-            stringval = s;
+            char *const oldstringval = stringval;
+            stringval = (char *)concat_str((const char_u *)stringval,
+                                           (const char_u *)s);
+            xfree(oldstringval);
+            s = stringval;
           }
         }
       }
       if (s != NULL) {
-        set_option_value((const char *)arg, n, (char *)s, opt_flags);
+        set_option_value((const char *)arg, n, s, opt_flags);
         arg_end = (char_u *)p;
       }
       *p = c1;
       xfree(stringval);
     }
-  }
-  /*
-   * ":let @r = expr": Set register contents.
-   */
-  else if (*arg == '@') {
-    ++arg;
-    if (op != NULL && (*op == '+' || *op == '-'))
-      EMSG2(_(e_letwrong), op);
-    else if (endchars != NULL
-             && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL)
-      EMSG(_(e_letunexp));
-    else {
-      char_u      *ptofree = NULL;
+  // ":let @r = expr": Set register contents.
+  } else if (*arg == '@') {
+    arg++;
+    if (op != NULL && (*op == '+' || *op == '-')) {
+      emsgf(_(e_letwrong), op);
+    } else if (endchars != NULL
+               && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) {
+      emsgf(_(e_letunexp));
+    } else {
       char_u      *s;
 
-      char_u *p = get_tv_string_chk(tv);
+      char_u *ptofree = NULL;
+      const char *p = tv_get_string_chk(tv);
       if (p != NULL && op != NULL && *op == '.') {
         s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
         if (s != NULL) {
-          p = ptofree = concat_str(s, p);
+          ptofree = concat_str(s, (const char_u *)p);
+          p = (const char *)ptofree;
           xfree(s);
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg, p, STRLEN(p), false);
+        write_reg_contents(*arg == '@' ? '"' : *arg,
+                           (const char_u *)p, STRLEN(p), false);
         arg_end = arg + 1;
       }
       xfree(ptofree);
@@ -2129,13 +2130,14 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
     } else {
       /* Get the index [expr] or the first index [expr: ]. */
       p = skipwhite(p + 1);
-      if (*p == ':')
-        empty1 = TRUE;
-      else {
-        empty1 = FALSE;
-        if (eval1(&p, &var1, TRUE) == FAIL)             /* recursive! */
+      if (*p == ':') {
+        empty1 = true;
+      } else {
+        empty1 = false;
+        if (eval1(&p, &var1, true) == FAIL) {  // Recursive!
           return NULL;
-        if (get_tv_string_chk(&var1) == NULL) {
+        }
+        if (!tv_check_str(&var1)) {
           // Not a number or string.
           tv_clear(&var1);
           return NULL;
@@ -2174,7 +2176,7 @@ static char_u *get_lval(char_u *const name, typval_T *const rettv,
             }
             return NULL;
           }
-          if (get_tv_string_chk(&var2) == NULL) {
+          if (!tv_check_str(&var2)) {
             // Not a number or string.
             if (!empty1) {
               tv_clear(&var1);
@@ -3810,16 +3812,15 @@ static int eval5(char_u **arg, typval_T *rettv, int evaluate)
       break;
 
     if ((op != '+' || rettv->v_type != VAR_LIST)
-        && (op == '.' || rettv->v_type != VAR_FLOAT)
-        ) {
-      /* For "list + ...", an illegal use of the first operand as
-       * a number cannot be determined before evaluating the 2nd
-       * operand: if this is also a list, all is ok.
-       * For "something . ...", "something - ..." or "non-list + ...",
-       * we know that the first operand needs to be a string or number
-       * without evaluating the 2nd operand.  So check before to avoid
-       * side effects after an error. */
-      if (evaluate && get_tv_string_chk(rettv) == NULL) {
+        && (op == '.' || rettv->v_type != VAR_FLOAT)) {
+      // For "list + ...", an illegal use of the first operand as
+      // a number cannot be determined before evaluating the 2nd
+      // operand: if this is also a list, all is ok.
+      // For "something . ...", "something - ..." or "non-list + ...",
+      // we know that the first operand needs to be a string or number
+      // without evaluating the 2nd operand.  So check before to avoid
+      // side effects after an error.
+      if (evaluate && !tv_check_str(rettv)) {
         tv_clear(rettv);
         return FAIL;
       }
@@ -3840,10 +3841,10 @@ static int eval5(char_u **arg, typval_T *rettv, int evaluate)
        */
       if (op == '.') {
         char buf1[NUMBUFLEN];
-        char_u buf2[NUMBUFLEN];
+        char buf2[NUMBUFLEN];
         // s1 already checked
         const char *const s1 = tv_get_string_buf(rettv, buf1);
-        const char *const s2 = (const char *)get_tv_string_buf_chk(&var2, buf2);
+        const char *const s2 = tv_get_string_buf_chk(&var2, buf2);
         if (s2 == NULL) {  // Type error?
           tv_clear(rettv);
           tv_clear(&var2);
@@ -4411,7 +4412,7 @@ eval_index (
       empty1 = true;
     } else if (eval1(arg, &var1, evaluate) == FAIL) {  // Recursive!
       return FAIL;
-    } else if (evaluate && get_tv_string_chk(&var1) == NULL) {
+    } else if (evaluate && !tv_check_str(&var1)) {
       // Not a number or string.
       tv_clear(&var1);
       return FAIL;
@@ -4430,7 +4431,7 @@ eval_index (
           tv_clear(&var1);
         }
         return FAIL;
-      } else if (evaluate && get_tv_string_chk(&var2) == NULL) {
+      } else if (evaluate && !tv_check_str(&var2)) {
         // Not a number or string.
         if (!empty1) {
           tv_clear(&var1);
@@ -4566,7 +4567,7 @@ eval_index (
         }
 
         if (len == -1) {
-          key = get_tv_string_chk(&var1);
+          key = (char_u *)tv_get_string_chk(&var1);
           if (key == NULL) {
             tv_clear(&var1);
             return FAIL;
@@ -5570,7 +5571,7 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
   char_u      *key = NULL;
   dictitem_T  *item;
   char_u      *start = skipwhite(*arg + 1);
-  char_u buf[NUMBUFLEN];
+  char buf[NUMBUFLEN];
 
   /*
    * First check if it's not a curly-braces thing: {expr}.
@@ -5602,9 +5603,9 @@ static int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
       goto failret;
     }
     if (evaluate) {
-      key = get_tv_string_buf_chk(&tvkey, buf);
+      key = (char_u *)tv_get_string_buf_chk(&tvkey, buf);
       if (key == NULL) {
-        // "key" is NULL when get_tv_string_buf_chk() gave an errmsg
+        // "key" is NULL when tv_get_string_buf_chk() gave an errmsg
         tv_clear(&tvkey);
         goto failret;
       }
@@ -6598,7 +6599,6 @@ static void f_api_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   long lnum;
-  char_u      *line;
   list_T      *l = NULL;
   listitem_T  *li = NULL;
   typval_T    *tv;
@@ -6622,21 +6622,23 @@ static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       li = l->lv_first;
     }
     for (;; ) {
-      if (l == NULL)
-        tv = &argvars[1];               /* append a string */
-      else if (li == NULL)
-        break;                          /* end of list */
-      else
-        tv = &li->li_tv;                /* append item from list */
-      line = get_tv_string_chk(tv);
-      if (line == NULL) {               /* type error */
-        rettv->vval.v_number = 1;               /* Failed */
+      if (l == NULL) {
+        tv = &argvars[1];  // Append a string.
+      } else if (li == NULL) {
+        break;  // End of list.
+      } else {
+        tv = &li->li_tv;  // Append item from list.
+      }
+      const char *const line = tv_get_string_chk(tv);
+      if (line == NULL) {  // Type error.
+        rettv->vval.v_number = 1;  // Failed.
         break;
       }
-      ml_append(lnum + added, line, (colnr_T)0, FALSE);
-      ++added;
-      if (l == NULL)
+      ml_append(lnum + added, (char_u *)line, (colnr_T)0, false);
+      added++;
+      if (l == NULL) {
         break;
+      }
       li = li->li_next;
     }
 
@@ -6802,7 +6804,7 @@ static void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   garray_T ga;
 
-  char *error = (char *)get_tv_string_chk(&argvars[0]);
+  const char *const error = tv_get_string_chk(&argvars[0]);
   if (vimvars[VV_EXCEPTION].vv_str == NULL) {
     prepare_assert_error(&ga);
     ga_concat(&ga, (char_u *)"v:exception is not set");
@@ -6821,22 +6823,22 @@ static void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "assert_fails(cmd [, error])" function
 static void f_assert_fails(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *cmd = get_tv_string_chk(&argvars[0]);
+  const char *const cmd = tv_get_string_chk(&argvars[0]);
   garray_T    ga;
 
   called_emsg = false;
   suppress_errthrow = true;
   emsg_silent = true;
-  do_cmdline_cmd((char *)cmd);
+  do_cmdline_cmd(cmd);
   if (!called_emsg) {
     prepare_assert_error(&ga);
-    ga_concat(&ga, (char_u *)"command did not fail: ");
-    ga_concat(&ga, cmd);
+    ga_concat(&ga, (const char_u *)"command did not fail: ");
+    ga_concat(&ga, (const char_u *)cmd);
     assert_error(&ga);
     ga_clear(&ga);
   } else if (argvars[1].v_type != VAR_UNKNOWN) {
-    char_u buf[NUMBUFLEN];
-    char *error = (char *)get_tv_string_buf_chk(&argvars[1], buf);
+    char buf[NUMBUFLEN];
+    const char *const error = tv_get_string_buf_chk(&argvars[1], buf);
 
     if (error == NULL
         || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL) {
@@ -6911,14 +6913,15 @@ static void f_assert_false(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void assert_match_common(typval_T *argvars, assert_type_T atype)
 {
-  char_u buf1[NUMBUFLEN];
-  char_u buf2[NUMBUFLEN];
-  char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1);
-  char_u *text = get_tv_string_buf_chk(&argvars[1], buf2);
+  char buf1[NUMBUFLEN];
+  char buf2[NUMBUFLEN];
+  const char *const pat = tv_get_string_buf_chk(&argvars[0], buf1);
+  const char *const text = tv_get_string_buf_chk(&argvars[1], buf2);
 
   if (pat == NULL || text == NULL) {
     EMSG(_(e_invarg));
-  } else if (pattern_match(pat, text, false) != (atype == ASSERT_MATCH)) {
+  } else if (pattern_match((char_u *)pat, (char_u *)text, false)
+             != (atype == ASSERT_MATCH)) {
     garray_T ga;
     prepare_assert_error(&ga);
     fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1], atype);
@@ -7107,7 +7110,6 @@ static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   bool error = false;
-  char_u *name;
 
   rettv->vval.v_number = -1;
   if (!tv_check_str_or_nr(&argvars[0])) {
@@ -7119,13 +7121,14 @@ static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   // If the buffer isn't found and the second argument is not zero create a
   // new buffer.
+  const char *name;
   if (buf == NULL
       && argvars[1].v_type != VAR_UNKNOWN
       && tv_get_number_chk(&argvars[1], &error) != 0
       && !error
-      && (name = get_tv_string_chk(&argvars[0])) != NULL
+      && (name = tv_get_string_chk(&argvars[0])) != NULL
       && !error) {
-    buf = buflist_new(name, NULL, (linenr_T)1, 0);
+    buf = buflist_new((char_u *)name, NULL, 1, 0);
   }
 
   if (buf != NULL) {
@@ -7190,24 +7193,23 @@ static void f_byte2line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void byteidx(typval_T *argvars, typval_T *rettv, int comp)
 {
-  char_u      *t;
-  char_u      *str;
-  long idx;
-
-  str = get_tv_string_chk(&argvars[0]);
-  idx = tv_get_number_chk(&argvars[1], NULL);
+  const char *const str = tv_get_string_chk(&argvars[0]);
+  varnumber_T idx = tv_get_number_chk(&argvars[1], NULL);
   rettv->vval.v_number = -1;
-  if (str == NULL || idx < 0)
+  if (str == NULL || idx < 0) {
     return;
+  }
 
-  t = str;
+  const char *t = str;
   for (; idx > 0; idx--) {
-    if (*t == NUL)              /* EOL reached */
+    if (*t == NUL) {  // EOL reached.
       return;
-    if (enc_utf8 && comp)
-      t += utf_ptr2len(t);
-    else
-      t += (*mb_ptr2len)(t);
+    }
+    if (enc_utf8 && comp) {
+      t += utf_ptr2len((const char_u *)t);
+    } else {
+      t += (*mb_ptr2len)((const char_u *)t);
+    }
   }
   rettv->vval.v_number = (varnumber_T)(t - str);
 }
@@ -7444,47 +7446,51 @@ static void f_complete_check(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_confirm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *message;
-  char_u      *buttons = NULL;
-  char_u buf[NUMBUFLEN];
-  char_u buf2[NUMBUFLEN];
+  char buf[NUMBUFLEN];
+  char buf2[NUMBUFLEN];
+  const char *message;
+  const char *buttons = NULL;
   int def = 1;
   int type = VIM_GENERIC;
-  char_u *typestr;
+  const char *typestr;
   bool error = false;
 
-  message = get_tv_string_chk(&argvars[0]);
-  if (message == NULL)
-    error = TRUE;
+  message = tv_get_string_chk(&argvars[0]);
+  if (message == NULL) {
+    error = true;
+  }
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    buttons = get_tv_string_buf_chk(&argvars[1], buf);
-    if (buttons == NULL)
-      error = TRUE;
+    buttons = tv_get_string_buf_chk(&argvars[1], buf);
+    if (buttons == NULL) {
+      error = true;
+    }
     if (argvars[2].v_type != VAR_UNKNOWN) {
       def = tv_get_number_chk(&argvars[2], &error);
       if (argvars[3].v_type != VAR_UNKNOWN) {
-        typestr = get_tv_string_buf_chk(&argvars[3], buf2);
-        if (typestr == NULL)
-          error = TRUE;
-        else {
+        typestr = tv_get_string_buf_chk(&argvars[3], buf2);
+        if (typestr == NULL) {
+          error = true;
+        } else {
           switch (TOUPPER_ASC(*typestr)) {
-          case 'E': type = VIM_ERROR; break;
-          case 'Q': type = VIM_QUESTION; break;
-          case 'I': type = VIM_INFO; break;
-          case 'W': type = VIM_WARNING; break;
-          case 'G': type = VIM_GENERIC; break;
+            case 'E': type = VIM_ERROR; break;
+            case 'Q': type = VIM_QUESTION; break;
+            case 'I': type = VIM_INFO; break;
+            case 'W': type = VIM_WARNING; break;
+            case 'G': type = VIM_GENERIC; break;
           }
         }
       }
     }
   }
 
-  if (buttons == NULL || *buttons == NUL)
-    buttons = (char_u *)_("&Ok");
+  if (buttons == NULL || *buttons == NUL) {
+    buttons = _("&Ok");
+  }
 
-  if (!error)
-    rettv->vval.v_number = do_dialog(type, NULL, message, buttons,
-        def, NULL, FALSE);
+  if (!error) {
+    rettv->vval.v_number = do_dialog(
+        type, NULL, (char_u *)message, (char_u *)buttons, def, NULL, false);
+  }
 }
 
 /*
@@ -7708,32 +7714,29 @@ static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   if (argvars[0].v_type != VAR_DICT) {
-    EMSG2(e_invarg2, "dict");
+    emsgf(_(e_invarg2), "dict");
     return;
   }
 
   if (argvars[1].v_type != VAR_STRING && argvars[1].v_type != VAR_NUMBER) {
-    EMSG2(e_invarg2, "key");
+    emsgf(_(e_invarg2), "key");
     return;
   }
 
-  char *key_pattern = (char *)get_tv_string_chk(argvars + 1);
-  assert(key_pattern);
-  const size_t key_len = STRLEN(argvars[1].vval.v_string);
-
-  if (key_len == 0) {
-    EMSG(_(e_emptykey));
+  const char *const key_pattern = tv_get_string_chk(argvars + 1);
+  if (key_pattern == NULL) {
     return;
   }
+  const size_t key_pattern_len = strlen(key_pattern);
 
   Callback callback;
   if (!callback_from_typval(&callback, &argvars[2])) {
-    EMSG2(e_invarg2, "funcref");
+    emsgf(_(e_invarg2), "funcref");
     return;
   }
 
   DictWatcher *watcher = xmalloc(sizeof(DictWatcher));
-  watcher->key_pattern = xmemdupz(key_pattern, key_len);
+  watcher->key_pattern = xmemdupz(key_pattern, key_pattern_len);
   watcher->callback = callback;
   watcher->busy = false;
   QUEUE_INSERT_TAIL(&argvars[0].vval.v_dict->watchers, &watcher->node);
@@ -7747,26 +7750,17 @@ static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   if (argvars[0].v_type != VAR_DICT) {
-    EMSG2(e_invarg2, "dict");
-    return;
-  }
-
-  if (argvars[1].v_type != VAR_STRING && argvars[1].v_type != VAR_NUMBER) {
-    EMSG2(e_invarg2, "key");
+    emsgf(_(e_invarg2), "dict");
     return;
   }
 
   if (argvars[2].v_type != VAR_FUNC && argvars[2].v_type != VAR_STRING) {
-    EMSG2(e_invarg2, "funcref");
+    emsgf(_(e_invarg2), "funcref");
     return;
   }
 
-  char *key_pattern = (char *)get_tv_string_chk(argvars + 1);
-  assert(key_pattern);
-  const size_t key_len = STRLEN(argvars[1].vval.v_string);
-
-  if (key_len == 0) {
-    EMSG(_(e_emptykey));
+  const char *const key_pattern = tv_get_string_chk(argvars + 1);
+  if (key_pattern == NULL) {
     return;
   }
 
@@ -7924,16 +7918,15 @@ static void f_escape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_eval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *s;
-
-  s = get_tv_string_chk(&argvars[0]);
-  if (s != NULL)
-    s = skipwhite(s);
+  const char *s = tv_get_string_chk(&argvars[0]);
+  if (s != NULL) {
+    s = (const char *)skipwhite((const char_u *)s);
+  }
 
-  char_u *p = s;
-  if (s == NULL || eval1(&s, rettv, TRUE) == FAIL) {
-    if (p != NULL && !aborting()) {
-      EMSG2(_(e_invexpr2), p);
+  const char *const expr_start = s;
+  if (s == NULL || eval1((char_u **)&s, rettv, true) == FAIL) {
+    if (expr_start != NULL && !aborting()) {
+      EMSG2(_(e_invexpr2), expr_start);
     }
     need_clr_eos = FALSE;
     rettv->v_type = VAR_NUMBER;
@@ -7965,75 +7958,74 @@ static void f_executable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
           && os_can_exe((const char_u *)name, NULL, false)));
 }
 
-static char_u * get_list_line(int c, void *cookie, int indent)
+static char_u *get_list_line(int c, void *cookie, int indent)
 {
-  listitem_T **p = (listitem_T **)cookie;
-  listitem_T *item = *p;
-  char_u buf[NUMBUFLEN];
-  char_u *s;
+  const listitem_T **const p = (const listitem_T **)cookie;
+  const listitem_T *item = *p;
 
   if (item == NULL) {
     return NULL;
   }
-  s = get_tv_string_buf_chk(&item->li_tv, buf);
+  char buf[NUMBUFLEN];
+  const char *const s = tv_get_string_buf_chk(&item->li_tv, buf);
   *p = item->li_next;
-  return s == NULL ? NULL : vim_strsave(s);
+  return (char_u *)(s == NULL ? NULL : xstrdup(s));
 }
 
 // "execute(command)" function
 static void f_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-    int save_msg_silent = msg_silent;
-    int save_emsg_silent = emsg_silent;
-    bool save_emsg_noredir = emsg_noredir;
-    garray_T *save_capture_ga = capture_ga;
+  const int save_msg_silent = msg_silent;
+  const int save_emsg_silent = emsg_silent;
+  const bool save_emsg_noredir = emsg_noredir;
+  garray_T *const save_capture_ga = capture_ga;
 
-    if (check_secure()) {
-      return;
-    }
+  if (check_secure()) {
+    return;
+  }
 
-    if (argvars[1].v_type != VAR_UNKNOWN) {
-      char_u buf[NUMBUFLEN];
-      char_u *s = get_tv_string_buf_chk(&argvars[1], buf);
+  if (argvars[1].v_type != VAR_UNKNOWN) {
+    char buf[NUMBUFLEN];
+    const char *const s = tv_get_string_buf_chk(&argvars[1], buf);
 
-      if (s == NULL) {
-        return;
-      }
-      if (STRNCMP(s, "silent", 6) == 0) {
-        msg_silent++;
-      }
-      if (STRCMP(s, "silent!") == 0) {
-        emsg_silent = true;
-        emsg_noredir = true;
-      }
-    } else {
+    if (s == NULL) {
+      return;
+    }
+    if (strncmp(s, S_LEN("silent")) == 0) {
       msg_silent++;
     }
-
-    garray_T capture_local;
-    ga_init(&capture_local, (int)sizeof(char), 80);
-    capture_ga = &capture_local;
-
-    if (argvars[0].v_type != VAR_LIST) {
-      do_cmdline_cmd(tv_get_string(&argvars[0]));
-    } else if (argvars[0].vval.v_list != NULL) {
-      list_T *const list = argvars[0].vval.v_list;
-      list->lv_refcount++;
-      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--;
+    if (strcmp(s, "silent!") == 0) {
+      emsg_silent = true;
+      emsg_noredir = true;
     }
-    msg_silent = save_msg_silent;
-    emsg_silent = save_emsg_silent;
-    emsg_noredir = save_emsg_noredir;
+  } else {
+    msg_silent++;
+  }
 
-    ga_append(capture_ga, NUL);
-    rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = vim_strsave(capture_ga->ga_data);
-    ga_clear(capture_ga);
+  garray_T capture_local;
+  ga_init(&capture_local, (int)sizeof(char), 80);
+  capture_ga = &capture_local;
 
-    capture_ga = save_capture_ga;
+  if (argvars[0].v_type != VAR_LIST) {
+    do_cmdline_cmd(tv_get_string(&argvars[0]));
+  } else if (argvars[0].vval.v_list != NULL) {
+    list_T *const list = argvars[0].vval.v_list;
+    list->lv_refcount++;
+    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--;
+  }
+  msg_silent = save_msg_silent;
+  emsg_silent = save_emsg_silent;
+  emsg_noredir = save_emsg_noredir;
+
+  ga_append(capture_ga, NUL);
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = vim_strsave(capture_ga->ga_data);
+  ga_clear(capture_ga);
+
+  capture_ga = save_capture_ga;
 }
 
 /// "exepath()" function
@@ -8231,7 +8223,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       if (argvars[2].v_type != VAR_UNKNOWN) {
         const char *const av[] = { "keep", "force", "error" };
 
-        action = (const char *)get_tv_string_chk(&argvars[2]);
+        action = tv_get_string_chk(&argvars[2]);
         if (action == NULL) {
           return;  // Type error; error message already given.
         }
@@ -8300,10 +8292,8 @@ static void f_filewritable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 {
-  char_u      *fresult = NULL;
-  char_u      *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
-  char_u      *p;
-  char_u pathbuf[NUMBUFLEN];
+  char_u *fresult = NULL;
+  char_u *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
   int count = 1;
   bool first = true;
   bool error = false;
@@ -8313,13 +8303,15 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 
   const char *fname = tv_get_string(&argvars[0]);
 
+  char pathbuf[NUMBUFLEN];
   if (argvars[1].v_type != VAR_UNKNOWN) {
-    p = get_tv_string_buf_chk(&argvars[1], pathbuf);
-    if (p == NULL)
-      error = TRUE;
-    else {
-      if (*p != NUL)
-        path = p;
+    const char *p = tv_get_string_buf_chk(&argvars[1], pathbuf);
+    if (p == NULL) {
+      error = true;
+    } else {
+      if (*p != NUL) {
+        path = (char_u *)p;
+      }
 
       if (argvars[2].v_type != VAR_UNKNOWN) {
         count = tv_get_number_chk(&argvars[2], &error);
@@ -8473,8 +8465,6 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
 {
   typval_T rettv;
   typval_T argv[3];
-  char_u buf[NUMBUFLEN];
-  char_u      *s;
   int retval = FAIL;
   int dummy;
 
@@ -8482,7 +8472,7 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
   argv[0] = vimvars[VV_KEY].vv_tv;
   argv[1] = vimvars[VV_VAL].vv_tv;
   if (expr->v_type == VAR_FUNC) {
-    s = expr->vval.v_string;
+    const char_u *const s = expr->vval.v_string;
     if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
                   0L, 0L, &dummy, true, NULL, NULL) == FAIL) {
       goto theend;
@@ -8490,23 +8480,24 @@ static int filter_map_one(typval_T *tv, typval_T *expr, int map, int *remp)
   } else if (expr->v_type == VAR_PARTIAL) {
     partial_T *partial = expr->vval.v_partial;
 
-    s = partial_name(partial);
+    const char_u *const s = partial_name(partial);
     if (call_func(s, (int)STRLEN(s), &rettv, 2, argv, NULL,
                   0L, 0L, &dummy, true, partial, NULL) == FAIL) {
       goto theend;
     }
   } else {
-    s = get_tv_string_buf_chk(expr, buf);
+    char buf[NUMBUFLEN];
+    const char *s = tv_get_string_buf_chk(expr, buf);
     if (s == NULL) {
       goto theend;
     }
-    s = skipwhite(s);
-    if (eval1(&s, &rettv, true) == FAIL) {
+    s = (const char *)skipwhite((const char_u *)s);
+    if (eval1((char_u **)&s, &rettv, true) == FAIL) {
       goto theend;
     }
 
     if (*s != NUL) {  // check for trailing chars after expr
-      EMSG2(_(e_invexpr2), s);
+      emsgf(_(e_invexpr2), s);
       goto theend;
     }
   }
@@ -8606,27 +8597,26 @@ static void f_fnameescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_fnamemodify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *fname;
-  char_u      *mods;
-  size_t usedlen = 0;
+  char_u *fbuf = NULL;
   size_t len;
-  char_u      *fbuf = NULL;
-  char_u buf[NUMBUFLEN];
-
-  fname = get_tv_string_chk(&argvars[0]);
-  mods = get_tv_string_buf_chk(&argvars[1], buf);
-  if (fname == NULL || mods == NULL)
+  char buf[NUMBUFLEN];
+  const char *fname = tv_get_string_chk(&argvars[0]);
+  const char *const mods = tv_get_string_buf_chk(&argvars[1], buf);
+  if (fname == NULL || mods == NULL) {
     fname = NULL;
-  else {
-    len = STRLEN(fname);
-    (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len);
+  } else {
+    len = strlen(fname);
+    size_t usedlen = 0;
+    (void)modify_fname((char_u *)mods, &usedlen, (char_u **)&fname, &fbuf,
+                       &len);
   }
 
   rettv->v_type = VAR_STRING;
-  if (fname == NULL)
+  if (fname == NULL) {
     rettv->vval.v_string = NULL;
-  else
-    rettv->vval.v_string = vim_strnsave(fname, len);
+  } else {
+    rettv->vval.v_string = (char_u *)xmemdupz(fname, len);
+  }
   xfree(fbuf);
 }
 
@@ -9257,7 +9247,7 @@ static void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     goto f_getbufvar_end;
   }
 
-  const char *varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *varname = tv_get_string_chk(&argvars[1]);
   emsg_off++;
   buf_T *const buf = get_buf_tv(&argvars[0], false);
 
@@ -9970,14 +9960,13 @@ static void f_getqflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "getreg()" function
 static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *strregname;
-  int regname;
+  const char *strregname;
   int arg2 = false;
   bool return_list = false;
   bool error = false;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
-    strregname = get_tv_string_chk(&argvars[0]);
+    strregname = tv_get_string_chk(&argvars[0]);
     error = strregname == NULL;
     if (argvars[1].v_type != VAR_UNKNOWN) {
       arg2 = tv_get_number_chk(&argvars[1], &error);
@@ -9986,16 +9975,17 @@ static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
       }
     }
   } else {
-    strregname = vimvars[VV_REG].vv_str;
+    strregname = (const char *)vimvars[VV_REG].vv_str;
   }
 
   if (error) {
     return;
   }
 
-  regname = (strregname == NULL ? '"' : *strregname);
-  if (regname == 0)
+  int regname = (uint8_t)(strregname == NULL ? '"' : *strregname);
+  if (regname == 0) {
     regname = '"';
+  }
 
   if (return_list) {
     rettv->v_type = VAR_LIST;
@@ -10016,23 +10006,24 @@ static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
  */
 static void f_getregtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u      *strregname;
-  int regname;
+  const char *strregname;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
-    strregname = get_tv_string_chk(&argvars[0]);
-    if (strregname == NULL) {       /* type error; errmsg already given */
+    strregname = tv_get_string_chk(&argvars[0]);
+    if (strregname == NULL) {  // Type error; errmsg already given.
       rettv->v_type = VAR_STRING;
       rettv->vval.v_string = NULL;
       return;
     }
-  } else
-    /* Default to v:register */
-    strregname = vimvars[VV_REG].vv_str;
+  } else {
+    // Default to v:register.
+    strregname = (const char *)vimvars[VV_REG].vv_str;
+  }
 
-  regname = (strregname == NULL ? '"' : *strregname);
-  if (regname == 0)
+  int regname = (uint8_t)(strregname == NULL ? '"' : *strregname);
+  if (regname == 0) {
     regname = '"';
+  }
 
   colnr_T reglen = 0;
   char buf[NUMBUFLEN + 2];
@@ -10108,7 +10099,7 @@ static void f_gettabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
 
-  const char *const varname = (const char *)get_tv_string_chk(&argvars[1]);
+  const char *const varname = tv_get_string_chk(&argvars[1]);
   tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
   if (tp != NULL && varname != NULL) {
     // Set tp to be our tabpage, temporarily.  Also set the window to the
@@ -10307,8 +10298,7 @@ getwinvar (
     tp = curtab;
   }
   win = find_win_by_nr(&argvars[off], tp);
-  const char *varname = (const char *)get_tv_string_chk(
-      &argvars[off + 1]);
+  const char *varname = tv_get_string_chk(&argvars[off + 1]);
 
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -10438,12 +10428,12 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   }
 
-  char_u buf1[NUMBUFLEN];
-  char_u *file = get_tv_string_buf_chk(&argvars[1], buf1);
+  char buf1[NUMBUFLEN];
+  const char *const file = tv_get_string_buf_chk(&argvars[1], buf1);
   if (file != NULL && !error) {
     garray_T ga;
     ga_init(&ga, (int)sizeof(char_u *), 10);
-    globpath((char_u *)tv_get_string(&argvars[0]), file, &ga, flags);
+    globpath((char_u *)tv_get_string(&argvars[0]), (char_u *)file, &ga, flags);
 
     if (rettv->v_type == VAR_STRING) {
       rettv->vval.v_string = ga_concat_strings_sep(&ga, "\n");
@@ -10464,12 +10454,13 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 // "glob2regpat()" function
 static void f_glob2regpat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char_u *pat = get_tv_string_chk(&argvars[0]);  // NULL on type error
+  const char *const pat = tv_get_string_chk(&argvars[0]);  // NULL on type error
 
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (pat == NULL)
-    ? NULL
-    : file_pat_to_reg_pat(pat, NULL, NULL, false);
+  rettv->vval.v_string = ((pat == NULL)
+                          ? NULL
+                          : file_pat_to_reg_pat((char_u *)pat, NULL, NULL,
+