Merge #11851 'eval.c: factor out eval/userfunc.c'

vim-patch:7.4.2058

1 files changed, 3374 insertions, 0 deletions

diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
new file mode 100644
index 0000000000..c55a29c67c
--- /dev/null
+++ b/src/nvim/eval/userfunc.c
@@ -0,0 +1,3374 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+// User defined function support
+
+#include "nvim/ascii.h"
+#include "nvim/charset.h"
+#include "nvim/edit.h"
+#include "nvim/eval.h"
+#include "nvim/eval/encode.h"
+#include "nvim/eval/userfunc.h"
+#include "nvim/ex_cmds2.h"
+#include "nvim/ex_docmd.h"
+#include "nvim/ex_getln.h"
+#include "nvim/ex_getln.h"
+#include "nvim/fileio.h"
+#include "nvim/getchar.h"
+#include "nvim/globals.h"
+#include "nvim/lua/executor.h"
+#include "nvim/misc1.h"
+#include "nvim/os/input.h"
+#include "nvim/regexp.h"
+#include "nvim/search.h"
+#include "nvim/ui.h"
+#include "nvim/vim.h"
+
+// flags used in uf_flags
+#define FC_ABORT    0x01          // abort function on error
+#define FC_RANGE    0x02          // function accepts range
+#define FC_DICT     0x04          // Dict function, uses "self"
+#define FC_CLOSURE  0x08          // closure, uses outer scope variables
+#define FC_DELETED  0x10          // :delfunction used while uf_refcount > 0
+#define FC_REMOVED  0x20          // function redefined while uf_refcount > 0
+#define FC_SANDBOX  0x40          // function defined in the sandbox
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+#include "eval/userfunc.c.generated.h"
+#endif
+
+hashtab_T func_hashtab;
+
+// Used by get_func_tv()
+static garray_T funcargs = GA_EMPTY_INIT_VALUE;
+
+// pointer to funccal for currently active function
+funccall_T *current_funccal = NULL;
+
+// Pointer to list of previously used funccal, still around because some
+// item in it is still being used.
+funccall_T *previous_funccal = NULL;
+
+static char *e_funcexts = N_(
+    "E122: Function %s already exists, add ! to replace it");
+static char *e_funcdict = N_("E717: Dictionary entry already exists");
+static char *e_funcref = N_("E718: Funcref required");
+static char *e_nofunc = N_("E130: Unknown function: %s");
+
+void func_init(void)
+{
+    hash_init(&func_hashtab);
+}
+
+/// Get function arguments.
+static int get_function_args(char_u **argp, char_u endchar, garray_T *newargs,
+                             int *varargs, bool skip)
+{
+  bool    mustend = false;
+  char_u  *arg = *argp;
+  char_u  *p = arg;
+  int     c;
+  int     i;
+
+  if (newargs != NULL) {
+    ga_init(newargs, (int)sizeof(char_u *), 3);
+  }
+
+  if (varargs != NULL) {
+    *varargs = false;
+  }
+
+  // Isolate the arguments: "arg1, arg2, ...)"
+  while (*p != endchar) {
+    if (p[0] == '.' && p[1] == '.' && p[2] == '.') {
+      if (varargs != NULL) {
+        *varargs = true;
+      }
+      p += 3;
+      mustend = true;
+    } else {
+      arg = p;
+      while (ASCII_ISALNUM(*p) || *p == '_') {
+        p++;
+      }
+      if (arg == p || isdigit(*arg)
+          || (p - arg == 9 && STRNCMP(arg, "firstline", 9) == 0)
+          || (p - arg == 8 && STRNCMP(arg, "lastline", 8) == 0)) {
+        if (!skip) {
+          EMSG2(_("E125: Illegal argument: %s"), arg);
+        }
+        break;
+      }
+      if (newargs != NULL) {
+        ga_grow(newargs, 1);
+        c = *p;
+        *p = NUL;
+        arg = vim_strsave(arg);
+
+        // Check for duplicate argument name.
+        for (i = 0; i < newargs->ga_len; i++) {
+          if (STRCMP(((char_u **)(newargs->ga_data))[i], arg) == 0) {
+            EMSG2(_("E853: Duplicate argument name: %s"), arg);
+            xfree(arg);
+            goto err_ret;
+          }
+        }
+        ((char_u **)(newargs->ga_data))[newargs->ga_len] = arg;
+        newargs->ga_len++;
+
+        *p = c;
+      }
+      if (*p == ',') {
+        p++;
+      } else {
+        mustend = true;
+      }
+    }
+    p = skipwhite(p);
+    if (mustend && *p != endchar) {
+      if (!skip) {
+        EMSG2(_(e_invarg2), *argp);
+      }
+      break;
+    }
+  }
+  if (*p != endchar) {
+    goto err_ret;
+  }
+  p++;  // skip "endchar"
+
+  *argp = p;
+  return OK;
+
+err_ret:
+  if (newargs != NULL) {
+    ga_clear_strings(newargs);
+  }
+  return FAIL;
+}
+
+/// Register function "fp" as using "current_funccal" as its scope.
+static void register_closure(ufunc_T *fp)
+{
+  if (fp->uf_scoped == current_funccal) {
+    // no change
+    return;
+  }
+  funccal_unref(fp->uf_scoped, fp, false);
+  fp->uf_scoped = current_funccal;
+  current_funccal->fc_refcount++;
+  ga_grow(&current_funccal->fc_funcs, 1);
+  ((ufunc_T **)current_funccal->fc_funcs.ga_data)
+    [current_funccal->fc_funcs.ga_len++] = fp;
+}
+
+/// Parse a lambda expression and get a Funcref from "*arg".
+///
+/// @return OK or FAIL.  Returns NOTDONE for dict or {expr}.
+int get_lambda_tv(char_u **arg, typval_T *rettv, bool evaluate)
+{
+  garray_T   newargs = GA_EMPTY_INIT_VALUE;
+  garray_T   *pnewargs;
+  ufunc_T    *fp = NULL;
+  int        varargs;
+  int        ret;
+  char_u     *start = skipwhite(*arg + 1);
+  char_u     *s, *e;
+  static int lambda_no = 0;
+  bool       *old_eval_lavars = eval_lavars_used;
+  bool       eval_lavars = false;
+
+  // First, check if this is a lambda expression. "->" must exists.
+  ret = get_function_args(&start, '-', NULL, NULL, true);
+  if (ret == FAIL || *start != '>') {
+    return NOTDONE;
+  }
+
+  // Parse the arguments again.
+  if (evaluate) {
+    pnewargs = &newargs;
+  } else {
+    pnewargs = NULL;
+  }
+  *arg = skipwhite(*arg + 1);
+  ret = get_function_args(arg, '-', pnewargs, &varargs, false);
+  if (ret == FAIL || **arg != '>') {
+    goto errret;
+  }
+
+  // Set up a flag for checking local variables and arguments.
+  if (evaluate) {
+    eval_lavars_used = &eval_lavars;
+  }
+
+  // Get the start and the end of the expression.
+  *arg = skipwhite(*arg + 1);
+  s = *arg;
+  ret = skip_expr(arg);
+  if (ret == FAIL) {
+    goto errret;
+  }
+  e = *arg;
+  *arg = skipwhite(*arg);
+  if (**arg != '}') {
+    goto errret;
+  }
+  (*arg)++;
+
+  if (evaluate) {
+    int len, flags = 0;
+    char_u *p;
+    char_u name[20];
+    partial_T *pt;
+    garray_T newlines;
+
+    lambda_no++;
+    snprintf((char *)name, sizeof(name), "<lambda>%d", lambda_no);
+
+    fp = xcalloc(1, offsetof(ufunc_T, uf_name) + STRLEN(name) + 1);
+    pt = xcalloc(1, sizeof(partial_T));
+
+    ga_init(&newlines, (int)sizeof(char_u *), 1);
+    ga_grow(&newlines, 1);
+
+    // Add "return " before the expression.
+    len = 7 + e - s + 1;
+    p = (char_u *)xmalloc(len);
+    ((char_u **)(newlines.ga_data))[newlines.ga_len++] = p;
+    STRCPY(p, "return ");
+    STRLCPY(p + 7, s, e - s + 1);
+
+    fp->uf_refcount = 1;
+    STRCPY(fp->uf_name, name);
+    hash_add(&func_hashtab, UF2HIKEY(fp));
+    fp->uf_args = newargs;
+    fp->uf_lines = newlines;
+    if (current_funccal != NULL && eval_lavars) {
+      flags |= FC_CLOSURE;
+      register_closure(fp);
+    } else {
+      fp->uf_scoped = NULL;
+    }
+
+    if (prof_def_func()) {
+      func_do_profile(fp);
+    }
+    if (sandbox) {
+      flags |= FC_SANDBOX;
+    }
+    fp->uf_varargs = true;
+    fp->uf_flags = flags;
+    fp->uf_calls = 0;
+    fp->uf_script_ctx = current_sctx;
+    fp->uf_script_ctx.sc_lnum += sourcing_lnum - newlines.ga_len;
+
+    pt->pt_func = fp;
+    pt->pt_refcount = 1;
+    rettv->vval.v_partial = pt;
+    rettv->v_type = VAR_PARTIAL;
+  }
+
+  eval_lavars_used = old_eval_lavars;
+  return OK;
+
+errret:
+  ga_clear_strings(&newargs);
+  xfree(fp);
+  eval_lavars_used = old_eval_lavars;
+  return FAIL;
+}
+
+/// Return name of the function corresponding to `name`
+///
+/// If `name` points to variable that is either a function or partial then
+/// corresponding function name is returned. Otherwise it returns `name` itself.
+///
+/// @param[in]  name  Function name to check.
+/// @param[in,out]  lenp  Location where length of the returned name is stored.
+///                       Must be set to the length of the `name` argument.
+/// @param[out]  partialp  Location where partial will be stored if found
+///                        function appears to be a partial. May be NULL if this
+///                        is not needed.
+/// @param[in]  no_autoload  If true, do not source autoload scripts if function
+///                          was not found.
+///
+/// @return name of the function.
+char_u *deref_func_name(const char *name, int *lenp,
+                               partial_T **const partialp, bool no_autoload)
+  FUNC_ATTR_NONNULL_ARG(1, 2)
+{
+  if (partialp != NULL) {
+    *partialp = NULL;
+  }
+
+  dictitem_T *const v = find_var(name, (size_t)(*lenp), NULL, no_autoload);
+  if (v != NULL && v->di_tv.v_type == VAR_FUNC) {
+    if (v->di_tv.vval.v_string == NULL) {  // just in case
+      *lenp = 0;
+      return (char_u *)"";
+    }
+    *lenp = (int)STRLEN(v->di_tv.vval.v_string);
+    return v->di_tv.vval.v_string;
+  }
+
+  if (v != NULL && v->di_tv.v_type == VAR_PARTIAL) {
+    partial_T *const pt = v->di_tv.vval.v_partial;
+
+    if (pt == NULL) {  // just in case
+      *lenp = 0;
+      return (char_u *)"";
+    }
+    if (partialp != NULL) {
+      *partialp = pt;
+    }
+    char_u *s = partial_name(pt);
+    *lenp = (int)STRLEN(s);
+    return s;
+  }
+
+  return (char_u *)name;
+}
+
+/// Give an error message with a function name.  Handle <SNR> things.
+///
+/// @param ermsg must be passed without translation (use N_() instead of _()).
+/// @param name function name
+void emsg_funcname(char *ermsg, const char_u *name)
+{
+  char_u *p;
+
+  if (*name == K_SPECIAL) {
+    p = concat_str((char_u *)"<SNR>", name + 3);
+  } else {
+    p = (char_u *)name;
+  }
+
+  EMSG2(_(ermsg), p);
+
+  if (p != name) {
+    xfree(p);
+  }
+}
+
+/*
+ * Allocate a variable for the result of a function.
+ * Return OK or FAIL.
+ */
+int
+get_func_tv(
+    const char_u *name,     // name of the function
+    int len,                // length of "name"
+    typval_T *rettv,
+    char_u **arg,           // argument, pointing to the '('
+    linenr_T firstline,     // first line of range
+    linenr_T lastline,      // last line of range
+    int *doesrange,         // return: function handled range
+    int evaluate,
+    partial_T *partial,     // for extra arguments
+    dict_T *selfdict        // Dictionary for "self"
+)
+{
+  char_u      *argp;
+  int ret = OK;
+  typval_T argvars[MAX_FUNC_ARGS + 1];          /* vars for arguments */
+  int argcount = 0;                     /* number of arguments found */
+
+  /*
+   * Get the arguments.
+   */
+  argp = *arg;
+  while (argcount < MAX_FUNC_ARGS - (partial == NULL ? 0 : partial->pt_argc)) {
+    argp = skipwhite(argp + 1);             // skip the '(' or ','
+    if (*argp == ')' || *argp == ',' || *argp == NUL) {
+      break;
+    }
+    if (eval1(&argp, &argvars[argcount], evaluate) == FAIL) {
+      ret = FAIL;
+      break;
+    }
+    ++argcount;
+    if (*argp != ',')
+      break;
+  }
+  if (*argp == ')')
+    ++argp;
+  else
+    ret = FAIL;
+
+  if (ret == OK) {
+    int i = 0;
+
+    if (get_vim_var_nr(VV_TESTING)) {
+      // Prepare for calling garbagecollect_for_testing(), need to know
+      // what variables are used on the call stack.
+      if (funcargs.ga_itemsize == 0) {
+        ga_init(&funcargs, (int)sizeof(typval_T *), 50);
+      }
+      for (i = 0; i < argcount; i++) {
+        ga_grow(&funcargs, 1);
+        ((typval_T **)funcargs.ga_data)[funcargs.ga_len++] = &argvars[i];
+      }
+    }
+    ret = call_func(name, len, rettv, argcount, argvars, NULL,
+                    firstline, lastline, doesrange, evaluate,
+                    partial, selfdict);
+
+    funcargs.ga_len -= i;
+  } else if (!aborting()) {
+    if (argcount == MAX_FUNC_ARGS) {
+      emsg_funcname(N_("E740: Too many arguments for function %s"), name);
+    } else {
+      emsg_funcname(N_("E116: Invalid arguments for function %s"), name);
+    }
+  }
+
+  while (--argcount >= 0) {
+    tv_clear(&argvars[argcount]);
+  }
+
+  *arg = skipwhite(argp);
+  return ret;
+}
+
+#define FLEN_FIXED 40
+
+/// Check whether function name starts with <SID> or s:
+///
+/// @warning Only works for names previously checked by eval_fname_script(), if
+///          it returned non-zero.
+///
+/// @param[in]  name  Name to check.
+///
+/// @return true if it starts with <SID> or s:, false otherwise.
+static inline bool eval_fname_sid(const char *const name)
+  FUNC_ATTR_PURE FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_WARN_UNUSED_RESULT
+  FUNC_ATTR_NONNULL_ALL
+{
+  return *name == 's' || TOUPPER_ASC(name[2]) == 'I';
+}
+
+/// In a script transform script-local names into actually used names
+///
+/// Transforms "<SID>" and "s:" prefixes to `K_SNR {N}` (e.g. K_SNR "123") and
+/// "<SNR>" prefix to `K_SNR`. Uses `fname_buf` buffer that is supposed to have
+/// #FLEN_FIXED + 1 length when it fits, otherwise it allocates memory.
+///
+/// @param[in]  name  Name to transform.
+/// @param  fname_buf  Buffer to save resulting function name to, if it fits.
+///                    Must have at least #FLEN_FIXED + 1 length.
+/// @param[out]  tofree  Location where pointer to an allocated memory is saved
+///                      in case result does not fit into fname_buf.
+/// @param[out]  error  Location where error type is saved, @see
+///                     FnameTransError.
+///
+/// @return transformed name: either `fname_buf` or a pointer to an allocated
+///         memory.
+static char_u *fname_trans_sid(const char_u *const name,
+                               char_u *const fname_buf,
+                               char_u **const tofree, int *const error)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  char_u *fname;
+  const int llen = eval_fname_script((const char *)name);
+  if (llen > 0) {
+    fname_buf[0] = K_SPECIAL;
+    fname_buf[1] = KS_EXTRA;
+    fname_buf[2] = (int)KE_SNR;
+    int i = 3;
+    if (eval_fname_sid((const char *)name)) {  // "<SID>" or "s:"
+      if (current_sctx.sc_sid <= 0) {
+        *error = ERROR_SCRIPT;
+      } else {
+        snprintf((char *)fname_buf + 3, FLEN_FIXED + 1, "%" PRId64 "_",
+                 (int64_t)current_sctx.sc_sid);
+        i = (int)STRLEN(fname_buf);
+      }
+    }
+    if (i + STRLEN(name + llen) < FLEN_FIXED) {
+      STRCPY(fname_buf + i, name + llen);
+      fname = fname_buf;
+    } else {
+      fname = xmalloc(i + STRLEN(name + llen) + 1);
+      *tofree = fname;
+      memmove(fname, fname_buf, (size_t)i);
+      STRCPY(fname + i, name + llen);
+    }
+  } else {
+    fname = (char_u *)name;
+  }
+
+  return fname;
+}
+
+/// Find a function by name, return pointer to it in ufuncs.
+/// @return NULL for unknown function.
+ufunc_T *find_func(const char_u *name)
+{
+  hashitem_T  *hi;
+
+  hi = hash_find(&func_hashtab, name);
+  if (!HASHITEM_EMPTY(hi))
+    return HI2UF(hi);
+  return NULL;
+}
+
+/*
+ * Copy the function name of "fp" to buffer "buf".
+ * "buf" must be able to hold the function name plus three bytes.
+ * Takes care of script-local function names.
+ */
+static void cat_func_name(char_u *buf, ufunc_T *fp)
+{
+  if (fp->uf_name[0] == K_SPECIAL) {
+    STRCPY(buf, "<SNR>");
+    STRCAT(buf, fp->uf_name + 3);
+  } else
+    STRCPY(buf, fp->uf_name);
+}
+
+/*
+ * Add a number variable "name" to dict "dp" with value "nr".
+ */
+static void add_nr_var(dict_T *dp, dictitem_T *v, char *name, varnumber_T nr)
+{
+#ifndef __clang_analyzer__
+  STRCPY(v->di_key, name);
+#endif
+  v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
+  tv_dict_add(dp, v);
+  v->di_tv.v_type = VAR_NUMBER;
+  v->di_tv.v_lock = VAR_FIXED;
+  v->di_tv.vval.v_number = nr;
+}
+
+/*
+ * Free "fc" and what it contains.
+ */
+static void
+free_funccal(
+    funccall_T *fc,
+    int free_val              // a: vars were allocated
+)
+{
+  for (int i = 0; i < fc->fc_funcs.ga_len; i++) {
+    ufunc_T *fp = ((ufunc_T **)(fc->fc_funcs.ga_data))[i];
+
+    // When garbage collecting a funccall_T may be freed before the
+    // function that references it, clear its uf_scoped field.
+    // The function may have been redefined and point to another
+    // funccal_T, don't clear it then.
+    if (fp != NULL && fp->uf_scoped == fc) {
+      fp->uf_scoped = NULL;
+    }
+  }
+  ga_clear(&fc->fc_funcs);
+
+  // The a: variables typevals may not have been allocated, only free the
+  // allocated variables.
+  vars_clear_ext(&fc->l_avars.dv_hashtab, free_val);
+
+  // Free all l: variables.
+  vars_clear(&fc->l_vars.dv_hashtab);
+
+  // Free the a:000 variables if they were allocated.
+  if (free_val) {
+    TV_LIST_ITER(&fc->l_varlist, li, {
+      tv_clear(TV_LIST_ITEM_TV(li));
+    });
+  }
+
+  func_ptr_unref(fc->func);
+  xfree(fc);
+}
+
+/// Handle the last part of returning from a function: free the local hashtable.
+/// Unless it is still in use by a closure.
+static void cleanup_function_call(funccall_T *fc)
+{
+  current_funccal = fc->caller;
+
+  // If the a:000 list and the l: and a: dicts are not referenced and there
+  // is no closure using it, we can free the funccall_T and what's in it.
+  if (!fc_referenced(fc)) {
+    free_funccal(fc, false);
+  } else {
+    // "fc" is still in use.  This can happen when returning "a:000",
+    // assigning "l:" to a global variable or defining a closure.
+    // Link "fc" in the list for garbage collection later.
+    fc->caller = previous_funccal;
+    previous_funccal = fc;
+
+    // Make a copy of the a: variables, since we didn't do that above.
+    TV_DICT_ITER(&fc->l_avars, di, {
+      tv_copy(&di->di_tv, &di->di_tv);
+    });
+
+    // Make a copy of the a:000 items, since we didn't do that above.
+    TV_LIST_ITER(&fc->l_varlist, li, {
+      tv_copy(TV_LIST_ITEM_TV(li), TV_LIST_ITEM_TV(li));
+    });
+  }
+}
+
+/// Unreference "fc": decrement the reference count and free it when it
+/// becomes zero.  "fp" is detached from "fc".
+///
+/// @param[in]   force   When true, we are exiting.
+static void funccal_unref(funccall_T *fc, ufunc_T *fp, bool force)
+{
+  funccall_T **pfc;
+  int i;
+
+  if (fc == NULL) {
+    return;
+  }
+
+  fc->fc_refcount--;
+  if (force ? fc->fc_refcount <= 0 : !fc_referenced(fc)) {
+    for (pfc = &previous_funccal; *pfc != NULL; pfc = &(*pfc)->caller) {
+      if (fc == *pfc) {
+        *pfc = fc->caller;
+        free_funccal(fc, true);
+        return;
+      }
+    }
+  }
+  for (i = 0; i < fc->fc_funcs.ga_len; i++) {
+    if (((ufunc_T **)(fc->fc_funcs.ga_data))[i] == fp) {
+      ((ufunc_T **)(fc->fc_funcs.ga_data))[i] = NULL;
+    }
+  }
+}
+
+/// Remove the function from the function hashtable.  If the function was
+/// deleted while it still has references this was already done.
+///
+/// @return true if the entry was deleted, false if it wasn't found.
+static bool func_remove(ufunc_T *fp)
+{
+  hashitem_T *hi = hash_find(&func_hashtab, UF2HIKEY(fp));
+
+  if (!HASHITEM_EMPTY(hi)) {
+    hash_remove(&func_hashtab, hi);
+    return true;
+  }
+
+  return false;
+}
+
+static void func_clear_items(ufunc_T *fp)
+{
+  ga_clear_strings(&(fp->uf_args));
+  ga_clear_strings(&(fp->uf_lines));
+
+  XFREE_CLEAR(fp->uf_tml_count);
+  XFREE_CLEAR(fp->uf_tml_total);
+  XFREE_CLEAR(fp->uf_tml_self);
+}
+
+/// Free all things that a function contains. Does not free the function
+/// itself, use func_free() for that.
+///
+/// param[in]        force        When true, we are exiting.
+static void func_clear(ufunc_T *fp, bool force)
+{
+  if (fp->uf_cleared) {
+    return;
+  }
+  fp->uf_cleared = true;
+
+  // clear this function
+  func_clear_items(fp);
+  funccal_unref(fp->uf_scoped, fp, force);
+}
+
+/// Free a function and remove it from the list of functions. Does not free
+/// what a function contains, call func_clear() first.
+///
+/// param[in]        fp        The function to free.
+static void func_free(ufunc_T *fp)
+{
+  // only remove it when not done already, otherwise we would remove a newer
+  // version of the function
+  if ((fp->uf_flags & (FC_DELETED | FC_REMOVED)) == 0) {
+    func_remove(fp);
+  }
+  xfree(fp);
+}
+
+/// Free all things that a function contains and free the function itself.
+///
+/// param[in]        force        When true, we are exiting.
+static void func_clear_free(ufunc_T *fp, bool force)
+{
+  func_clear(fp, force);
+  func_free(fp);
+}
+
+/// Call a user function
+///
+/// @param  fp  Function to call.
+/// @param[in]  argcount  Number of arguments.
+/// @param  argvars  Arguments.
+/// @param[out]  rettv  Return value.
+/// @param[in]  firstline  First line of range.
+/// @param[in]  lastline  Last line of range.
+/// @param  selfdict  Dictionary for "self" for dictionary functions.
+void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars,
+                    typval_T *rettv, linenr_T firstline, linenr_T lastline,
+                    dict_T *selfdict)
+  FUNC_ATTR_NONNULL_ARG(1, 3, 4)
+{
+  char_u      *save_sourcing_name;
+  linenr_T save_sourcing_lnum;
+  bool using_sandbox = false;
+  funccall_T  *fc;
+  int save_did_emsg;
+  static int depth = 0;
+  dictitem_T  *v;
+  int fixvar_idx = 0;           // index in fixvar[]
+  int ai;
+  bool islambda = false;
+  char_u numbuf[NUMBUFLEN];
+  char_u      *name;
+  proftime_T wait_start;
+  proftime_T call_start;
+  int started_profiling = false;
+  bool did_save_redo = false;
+  save_redo_T save_redo;
+
+  // If depth of calling is getting too high, don't execute the function
+  if (depth >= p_mfd) {
+    EMSG(_("E132: Function call depth is higher than 'maxfuncdepth'"));
+    rettv->v_type = VAR_NUMBER;
+    rettv->vval.v_number = -1;
+    return;
+  }
+  ++depth;
+  // Save search patterns and redo buffer.
+  save_search_patterns();
+  if (!ins_compl_active()) {
+    saveRedobuff(&save_redo);
+    did_save_redo = true;
+  }
+  ++fp->uf_calls;
+  // check for CTRL-C hit
+  line_breakcheck();
+  // prepare the funccall_T structure
+  fc = xmalloc(sizeof(funccall_T));
+  fc->caller = current_funccal;
+  current_funccal = fc;
+  fc->func = fp;
+  fc->rettv = rettv;
+  rettv->vval.v_number = 0;
+  fc->linenr = 0;
+  fc->returned = FALSE;
+  fc->level = ex_nesting_level;
+  // Check if this function has a breakpoint.
+  fc->breakpoint = dbg_find_breakpoint(false, fp->uf_name, (linenr_T)0);
+  fc->dbg_tick = debug_tick;
+
+  // Set up fields for closure.
+  fc->fc_refcount = 0;
+  fc->fc_copyID = 0;
+  ga_init(&fc->fc_funcs, sizeof(ufunc_T *), 1);
+  func_ptr_ref(fp);
+
+  if (STRNCMP(fp->uf_name, "<lambda>", 8) == 0) {
+    islambda = true;
+  }
+
+  // Note about using fc->fixvar[]: This is an array of FIXVAR_CNT variables
+  // with names up to VAR_SHORT_LEN long.  This avoids having to alloc/free
+  // each argument variable and saves a lot of time.
+  //
+  // Init l: variables.
+  init_var_dict(&fc->l_vars, &fc->l_vars_var, VAR_DEF_SCOPE);
+  if (selfdict != NULL) {
+    // Set l:self to "selfdict".  Use "name" to avoid a warning from
+    // some compiler that checks the destination size.
+    v = (dictitem_T *)&fc->fixvar[fixvar_idx++];
+#ifndef __clang_analyzer__
+    name = v->di_key;
+    STRCPY(name, "self");
+#endif
+    v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
+    tv_dict_add(&fc->l_vars, v);
+    v->di_tv.v_type = VAR_DICT;
+    v->di_tv.v_lock = 0;
+    v->di_tv.vval.v_dict = selfdict;
+    ++selfdict->dv_refcount;
+  }
+
+  /*
+   * Init a: variables.
+   * Set a:0 to "argcount".
+   * Set a:000 to a list with room for the "..." arguments.
+   */
+  init_var_dict(&fc->l_avars, &fc->l_avars_var, VAR_SCOPE);
+  add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++], "0",
+             (varnumber_T)(argcount - fp->uf_args.ga_len));
+  fc->l_avars.dv_lock = VAR_FIXED;
+  // Use "name" to avoid a warning from some compiler that checks the
+  // destination size.
+  v = (dictitem_T *)&fc->fixvar[fixvar_idx++];
+#ifndef __clang_analyzer__
+  name = v->di_key;
+  STRCPY(name, "000");
+#endif
+  v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
+  tv_dict_add(&fc->l_avars, v);
+  v->di_tv.v_type = VAR_LIST;
+  v->di_tv.v_lock = VAR_FIXED;
+  v->di_tv.vval.v_list = &fc->l_varlist;
+  tv_list_init_static(&fc->l_varlist);
+  tv_list_set_lock(&fc->l_varlist, VAR_FIXED);
+
+  // Set a:firstline to "firstline" and a:lastline to "lastline".
+  // Set a:name to named arguments.
+  // Set a:N to the "..." arguments.
+  add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++],
+             "firstline", (varnumber_T)firstline);
+  add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++],
+             "lastline", (varnumber_T)lastline);
+  for (int i = 0; i < argcount; i++) {
+    bool addlocal = false;
+
+    ai = i - fp->uf_args.ga_len;
+    if (ai < 0) {
+      // named argument a:name
+      name = FUNCARG(fp, i);
+      if (islambda) {
+        addlocal = true;
+      }
+    } else {
+      // "..." argument a:1, a:2, etc.
+      snprintf((char *)numbuf, sizeof(numbuf), "%d", ai + 1);
+      name = numbuf;
+    }
+    if (fixvar_idx < FIXVAR_CNT && STRLEN(name) <= VAR_SHORT_LEN) {
+      v = (dictitem_T *)&fc->fixvar[fixvar_idx++];
+      v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
+    } else {
+      v = xmalloc(sizeof(dictitem_T) + STRLEN(name));
+      v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX | DI_FLAGS_ALLOC;
+    }
+    STRCPY(v->di_key, name);
+
+    // Note: the values are copied directly to avoid alloc/free.
+    // "argvars" must have VAR_FIXED for v_lock.
+    v->di_tv = argvars[i];
+    v->di_tv.v_lock = VAR_FIXED;
+
+    if (addlocal) {
+      // Named arguments can be accessed without the "a:" prefix in lambda
+      // expressions. Add to the l: dict.
+      tv_copy(&v->di_tv, &v->di_tv);
+      tv_dict_add(&fc->l_vars, v);
+    } else {
+      tv_dict_add(&fc->l_avars, v);
+    }
+
+    if (ai >= 0 && ai < MAX_FUNC_ARGS) {
+      tv_list_append(&fc->l_varlist, &fc->l_listitems[ai]);
+      *TV_LIST_ITEM_TV(&fc->l_listitems[ai]) = argvars[i];
+      TV_LIST_ITEM_TV(&fc->l_listitems[ai])->v_lock = VAR_FIXED;
+    }
+  }
+
+  // Don't redraw while executing the function.
+  RedrawingDisabled++;
+  save_sourcing_name = sourcing_name;
+  save_sourcing_lnum = sourcing_lnum;
+  sourcing_lnum = 1;
+
+  if (fp->uf_flags & FC_SANDBOX) {
+    using_sandbox = true;
+    sandbox++;
+  }
+
+  // need space for new sourcing_name:
+  // * save_sourcing_name
+  // * "["number"].." or "function "
+  // * "<SNR>" + fp->uf_name - 3
+  // * terminating NUL
+  size_t len = (save_sourcing_name == NULL ? 0 : STRLEN(save_sourcing_name))
+               + STRLEN(fp->uf_name) + 27;
+  sourcing_name = xmalloc(len);
+  {
+    if (save_sourcing_name != NULL
+        && STRNCMP(save_sourcing_name, "function ", 9) == 0) {
+      vim_snprintf((char *)sourcing_name,
+                   len,
+                   "%s[%" PRId64 "]..",
+                   save_sourcing_name,
+                   (int64_t)save_sourcing_lnum);
+    } else {
+      STRCPY(sourcing_name, "function ");
+    }
+    cat_func_name(sourcing_name + STRLEN(sourcing_name), fp);
+
+    if (p_verbose >= 12) {
+      ++no_wait_return;
+      verbose_enter_scroll();
+
+      smsg(_("calling %s"), sourcing_name);
+      if (p_verbose >= 14) {
+        msg_puts("(");
+        for (int i = 0; i < argcount; i++) {
+          if (i > 0) {
+            msg_puts(", ");
+          }
+          if (argvars[i].v_type == VAR_NUMBER) {
+            msg_outnum((long)argvars[i].vval.v_number);
+          } else {
+            // Do not want errors such as E724 here.
+            emsg_off++;
+            char *tofree = encode_tv2string(&argvars[i], NULL);
+            emsg_off--;
+            if (tofree != NULL) {
+              char *s = tofree;
+              char buf[MSG_BUF_LEN];
+              if (vim_strsize((char_u *)s) > MSG_BUF_CLEN) {
+                trunc_string((char_u *)s, (char_u *)buf, MSG_BUF_CLEN,
+                             sizeof(buf));
+                s = buf;
+              }
+              msg_puts(s);
+              xfree(tofree);
+            }
+          }
+        }
+        msg_puts(")");
+      }
+      msg_puts("\n");  // don't overwrite this either
+
+      verbose_leave_scroll();
+      --no_wait_return;
+    }
+  }
+
+  const bool do_profiling_yes = do_profiling == PROF_YES;
+
+  bool func_not_yet_profiling_but_should =
+    do_profiling_yes
+    && !fp->uf_profiling && has_profiling(false, fp->uf_name, NULL);
+
+  if (func_not_yet_profiling_but_should) {
+    started_profiling = true;
+    func_do_profile(fp);
+  }
+
+  bool func_or_func_caller_profiling =
+    do_profiling_yes
+    && (fp->uf_profiling
+        || (fc->caller != NULL && fc->caller->func->uf_profiling));
+
+  if (func_or_func_caller_profiling) {
+    ++fp->uf_tm_count;
+    call_start = profile_start();
+    fp->uf_tm_children = profile_zero();
+  }
+
+  if (do_profiling_yes) {
+    script_prof_save(&wait_start);
+  }
+
+  const sctx_T save_current_sctx = current_sctx;
+  current_sctx = fp->uf_script_ctx;
+  save_did_emsg = did_emsg;
+  did_emsg = FALSE;
+
+  // call do_cmdline() to execute the lines
+  do_cmdline(NULL, get_func_line, (void *)fc,
+      DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
+
+  --RedrawingDisabled;
+
+  // when the function was aborted because of an error, return -1
+  if ((did_emsg
+       && (fp->uf_flags & FC_ABORT)) || rettv->v_type == VAR_UNKNOWN) {
+    tv_clear(rettv);
+    rettv->v_type = VAR_NUMBER;
+    rettv->vval.v_number = -1;
+  }
+
+  if (func_or_func_caller_profiling) {
+    call_start = profile_end(call_start);
+    call_start = profile_sub_wait(wait_start, call_start);  // -V614
+    fp->uf_tm_total = profile_add(fp->uf_tm_total, call_start);
+    fp->uf_tm_self = profile_self(fp->uf_tm_self, call_start,
+        fp->uf_tm_children);
+    if (fc->caller != NULL && fc->caller->func->uf_profiling) {
+      fc->caller->func->uf_tm_children =
+        profile_add(fc->caller->func->uf_tm_children, call_start);
+      fc->caller->func->uf_tml_children =
+        profile_add(fc->caller->func->uf_tml_children, call_start);
+    }
+    if (started_profiling) {
+      // make a ":profdel func" stop profiling the function
+      fp->uf_profiling = false;
+    }
+  }
+
+  // when being verbose, mention the return value
+  if (p_verbose >= 12) {
+    ++no_wait_return;
+    verbose_enter_scroll();
+
+    if (aborting())
+      smsg(_("%s aborted"), sourcing_name);
+    else if (fc->rettv->v_type == VAR_NUMBER)
+      smsg(_("%s returning #%" PRId64 ""),
+           sourcing_name, (int64_t)fc->rettv->vval.v_number);
+    else {
+      char_u buf[MSG_BUF_LEN];
+
+      // The value may be very long.  Skip the middle part, so that we
+      // have some idea how it starts and ends. smsg() would always
+      // truncate it at the end. Don't want errors such as E724 here.
+      emsg_off++;
+      char_u *s = (char_u *) encode_tv2string(fc->rettv, NULL);
+      char_u *tofree = s;
+      emsg_off--;
+      if (s != NULL) {
+        if (vim_strsize(s) > MSG_BUF_CLEN) {
+          trunc_string(s, buf, MSG_BUF_CLEN, MSG_BUF_LEN);
+          s = buf;
+        }
+        smsg(_("%s returning %s"), sourcing_name, s);
+        xfree(tofree);
+      }
+    }
+    msg_puts("\n");  // don't overwrite this either
+
+    verbose_leave_scroll();
+    --no_wait_return;
+  }
+
+  xfree(sourcing_name);
+  sourcing_name = save_sourcing_name;
+  sourcing_lnum = save_sourcing_lnum;
+  current_sctx = save_current_sctx;
+  if (do_profiling_yes) {
+    script_prof_restore(&wait_start);
+  }
+  if (using_sandbox) {
+    sandbox--;
+  }
+
+  if (p_verbose >= 12 && sourcing_name != NULL) {
+    ++no_wait_return;
+    verbose_enter_scroll();
+
+    smsg(_("continuing in %s"), sourcing_name);
+    msg_puts("\n");  // don't overwrite this either
+
+    verbose_leave_scroll();
+    --no_wait_return;
+  }
+
+  did_emsg |= save_did_emsg;
+  depth--;
+
+  cleanup_function_call(fc);
+
+  if (--fp->uf_calls <= 0 && fp->uf_refcount <= 0) {
+    // Function was unreferenced while being used, free it now.