Adding upstream version 2:9.1.0016.upstream/2%9.1.0016

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3168 insertions, 0 deletions

diff --git a/src/list.c b/src/list.c
new file mode 100644
index 0000000..b50cb03
--- /dev/null
+++ b/src/list.c
@@ -0,0 +1,3168 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * list.c: List support and container (List, Dict, Blob) functions.
+ */
+
+#include "vim.h"
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+
+// List heads for garbage collection.
+static list_T		*first_list = NULL;	// list of all lists
+
+#define FOR_ALL_WATCHERS(l, lw) \
+    for ((lw) = (l)->lv_watch; (lw) != NULL; (lw) = (lw)->lw_next)
+
+static void list_free_item(list_T *l, listitem_T *item);
+
+/*
+ * Add a watcher to a list.
+ */
+    void
+list_add_watch(list_T *l, listwatch_T *lw)
+{
+    lw->lw_next = l->lv_watch;
+    l->lv_watch = lw;
+}
+
+/*
+ * Remove a watcher from a list.
+ * No warning when it isn't found...
+ */
+    void
+list_rem_watch(list_T *l, listwatch_T *lwrem)
+{
+    listwatch_T	*lw, **lwp;
+
+    lwp = &l->lv_watch;
+    FOR_ALL_WATCHERS(l, lw)
+    {
+	if (lw == lwrem)
+	{
+	    *lwp = lw->lw_next;
+	    break;
+	}
+	lwp = &lw->lw_next;
+    }
+}
+
+/*
+ * Just before removing an item from a list: advance watchers to the next
+ * item.
+ */
+    static void
+list_fix_watch(list_T *l, listitem_T *item)
+{
+    listwatch_T	*lw;
+
+    FOR_ALL_WATCHERS(l, lw)
+	if (lw->lw_item == item)
+	    lw->lw_item = item->li_next;
+}
+
+    static void
+list_init(list_T *l)
+{
+    // Prepend the list to the list of lists for garbage collection.
+    if (first_list != NULL)
+	first_list->lv_used_prev = l;
+    l->lv_used_prev = NULL;
+    l->lv_used_next = first_list;
+    first_list = l;
+}
+
+/*
+ * Allocate an empty header for a list.
+ * Caller should take care of the reference count.
+ */
+    list_T *
+list_alloc(void)
+{
+    list_T  *l;
+
+    l = ALLOC_CLEAR_ONE(list_T);
+    if (l != NULL)
+	list_init(l);
+    return l;
+}
+
+/*
+ * list_alloc() with an ID for alloc_fail().
+ */
+    list_T *
+list_alloc_id(alloc_id_T id UNUSED)
+{
+#ifdef FEAT_EVAL
+    if (alloc_fail_id == id && alloc_does_fail(sizeof(list_T)))
+	return NULL;
+#endif
+    return (list_alloc());
+}
+
+/*
+ * Allocate space for a list, plus "count" items.
+ * This uses one allocation for efficiency.
+ * The reference count is not set.
+ * Next list_set_item() must be called for each item.
+ */
+    list_T *
+list_alloc_with_items(int count)
+{
+    list_T	*l;
+
+    l = (list_T *)alloc_clear(sizeof(list_T) + count * sizeof(listitem_T));
+    if (l == NULL)
+	return NULL;
+
+    list_init(l);
+
+    if (count <= 0)
+	return l;
+
+    listitem_T	*li = (listitem_T *)(l + 1);
+    int		i;
+
+    l->lv_len = count;
+    l->lv_with_items = count;
+    l->lv_first = li;
+    l->lv_u.mat.lv_last = li + count - 1;
+    for (i = 0; i < count; ++i)
+    {
+	if (i == 0)
+	    li->li_prev = NULL;
+	else
+	    li->li_prev = li - 1;
+	if (i == count - 1)
+	    li->li_next = NULL;
+	else
+	    li->li_next = li + 1;
+	++li;
+    }
+
+    return l;
+}
+
+/*
+ * Set item "idx" for a list previously allocated with list_alloc_with_items().
+ * The contents of "tv" is moved into the list item.
+ * Each item must be set exactly once.
+ */
+    void
+list_set_item(list_T *l, int idx, typval_T *tv)
+{
+    listitem_T	*li = (listitem_T *)(l + 1) + idx;
+
+    li->li_tv = *tv;
+}
+
+/*
+ * Allocate an empty list for a return value, with reference count set.
+ * Returns OK or FAIL.
+ */
+    int
+rettv_list_alloc(typval_T *rettv)
+{
+    list_T	*l = list_alloc();
+
+    if (l == NULL)
+	return FAIL;
+
+    rettv->v_lock = 0;
+    rettv_list_set(rettv, l);
+    return OK;
+}
+
+/*
+ * Same as rettv_list_alloc() but uses an allocation id for testing.
+ */
+    int
+rettv_list_alloc_id(typval_T *rettv, alloc_id_T id UNUSED)
+{
+#ifdef FEAT_EVAL
+    if (alloc_fail_id == id && alloc_does_fail(sizeof(list_T)))
+	return FAIL;
+#endif
+    return rettv_list_alloc(rettv);
+}
+
+
+/*
+ * Set a list as the return value.  Increments the reference count.
+ */
+    void
+rettv_list_set(typval_T *rettv, list_T *l)
+{
+    rettv->v_type = VAR_LIST;
+    rettv->vval.v_list = l;
+    if (l != NULL)
+	++l->lv_refcount;
+}
+
+/*
+ * Unreference a list: decrement the reference count and free it when it
+ * becomes zero.
+ */
+    void
+list_unref(list_T *l)
+{
+    if (l != NULL && --l->lv_refcount <= 0)
+	list_free(l);
+}
+
+/*
+ * Free a list, including all non-container items it points to.
+ * Ignores the reference count.
+ */
+    static void
+list_free_contents(list_T *l)
+{
+    listitem_T *item;
+
+    if (l->lv_first != &range_list_item)
+	for (item = l->lv_first; item != NULL; item = l->lv_first)
+	{
+	    // Remove the item before deleting it.
+	    l->lv_first = item->li_next;
+	    clear_tv(&item->li_tv);
+	    list_free_item(l, item);
+	}
+}
+
+/*
+ * Go through the list of lists and free items without the copyID.
+ * But don't free a list that has a watcher (used in a for loop), these
+ * are not referenced anywhere.
+ */
+    int
+list_free_nonref(int copyID)
+{
+    list_T	*ll;
+    int		did_free = FALSE;
+
+    for (ll = first_list; ll != NULL; ll = ll->lv_used_next)
+	if ((ll->lv_copyID & COPYID_MASK) != (copyID & COPYID_MASK)
+						      && ll->lv_watch == NULL)
+	{
+	    // Free the List and ordinary items it contains, but don't recurse
+	    // into Lists and Dictionaries, they will be in the list of dicts
+	    // or list of lists.
+	    list_free_contents(ll);
+	    did_free = TRUE;
+	}
+    return did_free;
+}
+
+    static void
+list_free_list(list_T  *l)
+{
+    // Remove the list from the list of lists for garbage collection.
+    if (l->lv_used_prev == NULL)
+	first_list = l->lv_used_next;
+    else
+	l->lv_used_prev->lv_used_next = l->lv_used_next;
+    if (l->lv_used_next != NULL)
+	l->lv_used_next->lv_used_prev = l->lv_used_prev;
+
+    free_type(l->lv_type);
+    vim_free(l);
+}
+
+    void
+list_free_items(int copyID)
+{
+    list_T	*ll, *ll_next;
+
+    for (ll = first_list; ll != NULL; ll = ll_next)
+    {
+	ll_next = ll->lv_used_next;
+	if ((ll->lv_copyID & COPYID_MASK) != (copyID & COPYID_MASK)
+						      && ll->lv_watch == NULL)
+	{
+	    // Free the List and ordinary items it contains, but don't recurse
+	    // into Lists and Dictionaries, they will be in the list of dicts
+	    // or list of lists.
+	    list_free_list(ll);
+	}
+    }
+}
+
+    void
+list_free(list_T *l)
+{
+    if (in_free_unref_items)
+	return;
+
+    list_free_contents(l);
+    list_free_list(l);
+}
+
+/*
+ * Allocate a list item.
+ * It is not initialized, don't forget to set v_lock.
+ */
+    listitem_T *
+listitem_alloc(void)
+{
+    return ALLOC_ONE(listitem_T);
+}
+
+/*
+ * Free a list item, unless it was allocated together with the list itself.
+ * Does not clear the value.  Does not notify watchers.
+ */
+    static void
+list_free_item(list_T *l, listitem_T *item)
+{
+    if (l->lv_with_items == 0 || item < (listitem_T *)l
+			   || item >= (listitem_T *)(l + 1) + l->lv_with_items)
+	vim_free(item);
+}
+
+/*
+ * Free a list item, unless it was allocated together with the list itself.
+ * Also clears the value.  Does not notify watchers.
+ */
+    void
+listitem_free(list_T *l, listitem_T *item)
+{
+    clear_tv(&item->li_tv);
+    list_free_item(l, item);
+}
+
+/*
+ * Remove a list item from a List and free it.  Also clears the value.
+ */
+    void
+listitem_remove(list_T *l, listitem_T *item)
+{
+    vimlist_remove(l, item, item);
+    listitem_free(l, item);
+}
+
+/*
+ * Get the number of items in a list.
+ */
+    long
+list_len(list_T *l)
+{
+    if (l == NULL)
+	return 0L;
+    return l->lv_len;
+}
+
+/*
+ * Return TRUE when two lists have exactly the same values.
+ */
+    int
+list_equal(
+    list_T	*l1,
+    list_T	*l2,
+    int		ic,	// ignore case for strings
+    int		recursive)  // TRUE when used recursively
+{
+    listitem_T	*item1, *item2;
+
+    if (l1 == l2)
+	return TRUE;
+    if (list_len(l1) != list_len(l2))
+	return FALSE;
+    if (list_len(l1) == 0)
+	// empty and NULL list are considered equal
+	return TRUE;
+    if (l1 == NULL || l2 == NULL)
+	return FALSE;
+
+    CHECK_LIST_MATERIALIZE(l1);
+    CHECK_LIST_MATERIALIZE(l2);
+
+    for (item1 = l1->lv_first, item2 = l2->lv_first;
+	    item1 != NULL && item2 != NULL;
+			       item1 = item1->li_next, item2 = item2->li_next)
+	if (!tv_equal(&item1->li_tv, &item2->li_tv, ic, recursive))
+	    return FALSE;
+    return item1 == NULL && item2 == NULL;
+}
+
+/*
+ * Locate item with index "n" in list "l" and return it.
+ * A negative index is counted from the end; -1 is the last item.
+ * Returns NULL when "n" is out of range.
+ */
+    listitem_T *
+list_find(list_T *l, long n)
+{
+    listitem_T	*item;
+    long	idx;
+
+    if (l == NULL)
+	return NULL;
+
+    // Negative index is relative to the end.
+    if (n < 0)
+	n = l->lv_len + n;
+
+    // Check for index out of range.
+    if (n < 0 || n >= l->lv_len)
+	return NULL;
+
+    CHECK_LIST_MATERIALIZE(l);
+
+    // range_list_materialize may reset l->lv_len
+    if (n >= l->lv_len)
+	return NULL;
+
+    // When there is a cached index may start search from there.
+    if (l->lv_u.mat.lv_idx_item != NULL)
+    {
+	if (n < l->lv_u.mat.lv_idx / 2)
+	{
+	    // closest to the start of the list
+	    item = l->lv_first;
+	    idx = 0;
+	}
+	else if (n > (l->lv_u.mat.lv_idx + l->lv_len) / 2)
+	{
+	    // closest to the end of the list
+	    item = l->lv_u.mat.lv_last;
+	    idx = l->lv_len - 1;
+	}
+	else
+	{
+	    // closest to the cached index
+	    item = l->lv_u.mat.lv_idx_item;
+	    idx = l->lv_u.mat.lv_idx;
+	}
+    }
+    else
+    {
+	if (n < l->lv_len / 2)
+	{
+	    // closest to the start of the list
+	    item = l->lv_first;
+	    idx = 0;
+	}
+	else
+	{
+	    // closest to the end of the list
+	    item = l->lv_u.mat.lv_last;
+	    idx = l->lv_len - 1;
+	}
+    }
+
+    while (n > idx)
+    {
+	// search forward
+	item = item->li_next;
+	++idx;
+    }
+    while (n < idx)
+    {
+	// search backward
+	item = item->li_prev;
+	--idx;
+    }
+
+    // cache the used index
+    l->lv_u.mat.lv_idx = idx;
+    l->lv_u.mat.lv_idx_item = item;
+
+    return item;
+}
+
+/*
+ * Get list item "l[idx]" as a number.
+ */
+    long
+list_find_nr(
+    list_T	*l,
+    long	idx,
+    int		*errorp)	// set to TRUE when something wrong
+{
+    listitem_T	*li;
+
+    if (l != NULL && l->lv_first == &range_list_item)
+    {
+	long	    n = idx;
+
+	// not materialized range() list: compute the value.
+	// Negative index is relative to the end.
+	if (n < 0)
+	    n = l->lv_len + n;
+
+	// Check for index out of range.
+	if (n < 0 || n >= l->lv_len)
+	{
+	    if (errorp != NULL)
+		*errorp = TRUE;
+	    return -1L;
+	}
+
+	return l->lv_u.nonmat.lv_start + n * l->lv_u.nonmat.lv_stride;
+    }
+
+    li = list_find(l, idx);
+    if (li == NULL)
+    {
+	if (errorp != NULL)
+	    *errorp = TRUE;
+	return -1L;
+    }
+    return (long)tv_get_number_chk(&li->li_tv, errorp);
+}
+
+/*
+ * Get list item "l[idx - 1]" as a string.  Returns NULL for failure.
+ */
+    char_u *
+list_find_str(list_T *l, long idx)
+{
+    listitem_T	*li;
+
+    li = list_find(l, idx - 1);
+    if (li == NULL)
+    {
+	semsg(_(e_list_index_out_of_range_nr), idx);
+	return NULL;
+    }
+    return tv_get_string(&li->li_tv);
+}
+
+/*
+ * Like list_find() but when a negative index is used that is not found use
+ * zero and set "idx" to zero.  Used for first index of a range.
+ */
+    listitem_T *
+list_find_index(list_T *l, long *idx)
+{
+    listitem_T *li = list_find(l, *idx);
+
+    if (li != NULL)
+	return li;
+
+    if (*idx < 0)
+    {
+	*idx = 0;
+	li = list_find(l, *idx);
+    }
+    return li;
+}
+
+/*
+ * Locate "item" list "l" and return its index.
+ * Returns -1 when "item" is not in the list.
+ */
+    long
+list_idx_of_item(list_T *l, listitem_T *item)
+{
+    long	idx = 0;
+    listitem_T	*li;
+
+    if (l == NULL)
+	return -1;
+    CHECK_LIST_MATERIALIZE(l);
+    idx = 0;
+    for (li = l->lv_first; li != NULL && li != item; li = li->li_next)
+	++idx;
+    if (li == NULL)
+	return -1;
+    return idx;
+}
+
+/*
+ * Append item "item" to the end of list "l".
+ */
+    void
+list_append(list_T *l, listitem_T *item)
+{
+    CHECK_LIST_MATERIALIZE(l);
+    if (l->lv_u.mat.lv_last == NULL)
+    {
+	// empty list
+	l->lv_first = item;
+	item->li_prev = NULL;
+    }
+    else
+    {
+	l->lv_u.mat.lv_last->li_next = item;
+	item->li_prev = l->lv_u.mat.lv_last;
+    }
+    l->lv_u.mat.lv_last = item;
+    ++l->lv_len;
+    item->li_next = NULL;
+}
+
+/*
+ * Append typval_T "tv" to the end of list "l".  "tv" is copied.
+ * Return FAIL when out of memory or the type is wrong.
+ */
+    int
+list_append_tv(list_T *l, typval_T *tv)
+{
+    listitem_T	*li;
+
+    if (l->lv_type != NULL && l->lv_type->tt_member != NULL
+		&& check_typval_arg_type(l->lv_type->tt_member, tv,
+							      NULL, 0) == FAIL)
+	return FAIL;
+    li = listitem_alloc();
+    if (li == NULL)
+	return FAIL;
+    copy_tv(tv, &li->li_tv);
+    list_append(l, li);
+    return OK;
+}
+
+/*
+ * As list_append_tv() but move the value instead of copying it.
+ * Return FAIL when out of memory.
+ */
+    static int
+list_append_tv_move(list_T *l, typval_T *tv)
+{
+    listitem_T	*li = listitem_alloc();
+
+    if (li == NULL)
+	return FAIL;
+    li->li_tv = *tv;
+    list_append(l, li);
+    return OK;
+}
+
+/*
+ * Add a dictionary to a list.  Used by getqflist().
+ * Return FAIL when out of memory.
+ */
+    int
+list_append_dict(list_T *list, dict_T *dict)
+{
+    listitem_T	*li = listitem_alloc();
+
+    if (li == NULL)
+	return FAIL;
+    li->li_tv.v_type = VAR_DICT;
+    li->li_tv.v_lock = 0;
+    li->li_tv.vval.v_dict = dict;
+    list_append(list, li);
+    ++dict->dv_refcount;
+    return OK;
+}
+
+/*
+ * Append list2 to list1.
+ * Return FAIL when out of memory.
+ */
+    int
+list_append_list(list_T *list1, list_T *list2)
+{
+    listitem_T	*li = listitem_alloc();
+
+    if (li == NULL)
+	return FAIL;
+    li->li_tv.v_type = VAR_LIST;
+    li->li_tv.v_lock = 0;
+    li->li_tv.vval.v_list = list2;
+    list_append(list1, li);
+    ++list2->lv_refcount;
+    return OK;
+}
+
+/*
+ * Make a copy of "str" and append it as an item to list "l".
+ * When "len" >= 0 use "str[len]".
+ * Returns FAIL when out of memory.
+ */
+    int
+list_append_string(list_T *l, char_u *str, int len)
+{
+    listitem_T *li = listitem_alloc();
+
+    if (li == NULL)
+	return FAIL;
+    list_append(l, li);
+    li->li_tv.v_type = VAR_STRING;
+    li->li_tv.v_lock = 0;
+    if (str == NULL)
+	li->li_tv.vval.v_string = NULL;
+    else if ((li->li_tv.vval.v_string = (len >= 0 ? vim_strnsave(str, len)
+						 : vim_strsave(str))) == NULL)
+	return FAIL;
+    return OK;
+}
+
+/*
+ * Append "n" to list "l".
+ * Returns FAIL when out of memory.
+ */
+    int
+list_append_number(list_T *l, varnumber_T n)
+{
+    listitem_T	*li;
+
+    li = listitem_alloc();
+    if (li == NULL)
+	return FAIL;
+    li->li_tv.v_type = VAR_NUMBER;
+    li->li_tv.v_lock = 0;
+    li->li_tv.vval.v_number = n;
+    list_append(l, li);
+    return OK;
+}
+
+/*
+ * Insert typval_T "tv" in list "l" before "item".
+ * If "item" is NULL append at the end.
+ * Return FAIL when out of memory or the type is wrong.
+ */
+    int
+list_insert_tv(list_T *l, typval_T *tv, listitem_T *item)
+{
+    listitem_T	*ni;
+
+    if (l->lv_type != NULL && l->lv_type->tt_member != NULL
+		&& check_typval_arg_type(l->lv_type->tt_member, tv,
+							      NULL, 0) == FAIL)
+	return FAIL;
+    ni = listitem_alloc();
+    if (ni == NULL)
+	return FAIL;
+    copy_tv(tv, &ni->li_tv);
+    list_insert(l, ni, item);
+    return OK;
+}
+
+    void
+list_insert(list_T *l, listitem_T *ni, listitem_T *item)
+{
+    CHECK_LIST_MATERIALIZE(l);
+    if (item == NULL)
+	// Append new item at end of list.
+	list_append(l, ni);
+    else
+    {
+	// Insert new item before existing item.
+	ni->li_prev = item->li_prev;
+	ni->li_next = item;
+	if (item->li_prev == NULL)
+	{
+	    l->lv_first = ni;
+	    ++l->lv_u.mat.lv_idx;
+	}
+	else
+	{
+	    item->li_prev->li_next = ni;
+	    l->lv_u.mat.lv_idx_item = NULL;
+	}
+	item->li_prev = ni;
+	++l->lv_len;
+    }
+}
+
+/*
+ * Get the list item in "l" with index "n1".  "n1" is adjusted if needed.
+ * In Vim9, it is at the end of the list, add an item if "can_append" is TRUE.
+ * Return NULL if there is no such item.
+ */
+    listitem_T *
+check_range_index_one(list_T *l, long *n1, int can_append, int quiet)
+{
+    long	orig_n1 = *n1;
+    listitem_T	*li = list_find_index(l, n1);
+
+    if (li != NULL)
+	return li;
+
+    // Vim9: Allow for adding an item at the end.
+    if (can_append && in_vim9script()
+	    && *n1 == l->lv_len && l->lv_lock == 0)
+    {
+	list_append_number(l, 0);
+	li = list_find_index(l, n1);
+    }
+    if (li == NULL)
+    {
+	if (!quiet)
+	    semsg(_(e_list_index_out_of_range_nr), orig_n1);
+	return NULL;
+    }
+    return li;
+}
+
+/*
+ * Check that "n2" can be used as the second index in a range of list "l".
+ * If "n1" or "n2" is negative it is changed to the positive index.
+ * "li1" is the item for item "n1".
+ * Return OK or FAIL.
+ */
+    int
+check_range_index_two(
+	list_T	    *l,
+	long	    *n1,
+	listitem_T  *li1,
+	long	    *n2,
+	int	    quiet)
+{
+    if (*n2 < 0)
+    {
+	listitem_T	*ni = list_find(l, *n2);
+
+	if (ni == NULL)
+	{
+	    if (!quiet)
+		semsg(_(e_list_index_out_of_range_nr), *n2);
+	    return FAIL;
+	}
+	*n2 = list_idx_of_item(l, ni);
+    }
+
+    // Check that n2 isn't before n1.
+    if (*n1 < 0)
+	*n1 = list_idx_of_item(l, li1);
+    if (*n2 < *n1)
+    {
+	if (!quiet)
+	    semsg(_(e_list_index_out_of_range_nr), *n2);
+	return FAIL;
+    }
+    return OK;
+}
+
+/*
+ * Assign values from list "src" into a range of "dest".
+ * "idx1_arg" is the index of the first item in "dest" to be replaced.
+ * "idx2" is the index of last item to be replaced, but when "empty_idx2" is
+ * TRUE then replace all items after "idx1".
+ * "op" is the operator, normally "=" but can be "+=" and the like.
+ * "varname" is used for error messages.
+ * Returns OK or FAIL.
+ */
+    int
+list_assign_range(
+	list_T	    *dest,
+	list_T	    *src,
+	long	    idx1_arg,
+	long	    idx2,
+	int	    empty_idx2,
+	char_u	    *op,
+	char_u	    *varname)
+{
+    listitem_T	*src_li;
+    listitem_T	*dest_li;
+    long	idx1 = idx1_arg;
+    listitem_T	*first_li = list_find_index(dest, &idx1);
+    long	idx;
+    type_T	*member_type = NULL;
+
+    // Check whether any of the list items is locked before making any changes.
+    idx = idx1;
+    dest_li = first_li;
+    for (src_li = src->lv_first; src_li != NULL && dest_li != NULL; )
+    {
+	if (value_check_lock(dest_li->li_tv.v_lock, varname, FALSE))
+	    return FAIL;
+	src_li = src_li->li_next;
+	if (src_li == NULL || (!empty_idx2 && idx2 == idx))
+	    break;
+	dest_li = dest_li->li_next;
+	++idx;
+    }
+
+    if (in_vim9script() && dest->lv_type != NULL
+					   && dest->lv_type->tt_member != NULL)
+	member_type = dest->lv_type->tt_member;
+
+    // Assign the List values to the list items.
+    idx = idx1;
+    dest_li = first_li;
+    for (src_li = src->lv_first; src_li != NULL; )
+    {
+	if (op != NULL && *op != '=')
+	    tv_op(&dest_li->li_tv, &src_li->li_tv, op);
+	else
+	{
+	    if (member_type != NULL
+		    && check_typval_arg_type(member_type, &src_li->li_tv,
+							      NULL, 0) == FAIL)
+		return FAIL;
+	    clear_tv(&dest_li->li_tv);
+	    copy_tv(&src_li->li_tv, &dest_li->li_tv);
+	}
+	src_li = src_li->li_next;
+	if (src_li == NULL || (!empty_idx2 && idx2 == idx))
+	    break;
+	if (dest_li->li_next == NULL)
+	{
+	    // Need to add an empty item.
+	    if (list_append_number(dest, 0) == FAIL)
+	    {
+		src_li = NULL;
+		break;
+	    }
+	}
+	dest_li = dest_li->li_next;
+	++idx;
+    }
+    if (src_li != NULL)
+    {
+	emsg(_(e_list_value_has_more_items_than_targets));
+	return FAIL;
+    }
+    if (empty_idx2
+	    ? (dest_li != NULL && dest_li->li_next != NULL)
+	    : idx != idx2)
+    {
+	emsg(_(e_list_value_does_not_have_enough_items));
+	return FAIL;
+    }
+    return OK;
+}
+
+/*
+ * Flatten up to "maxitems" in "list", starting at "first" to depth "maxdepth".
+ * When "first" is NULL use the first item.
+ * It does nothing if "maxdepth" is 0.
+ * Returns FAIL when out of memory.
+ */
+    static void
+list_flatten(list_T *list, listitem_T *first, long maxitems, long maxdepth)
+{
+    listitem_T	*item;
+    int		done = 0;
+
+    if (maxdepth == 0)
+	return;
+    CHECK_LIST_MATERIALIZE(list);
+    if (first == NULL)
+	item = list->lv_first;
+    else
+	item = first;
+
+    while (item != NULL && done < maxitems)
+    {
+	listitem_T	*next = item->li_next;
+
+	fast_breakcheck();
+	if (got_int)
+	    return;
+
+	if (item->li_tv.v_type == VAR_LIST)
+	{
+	    list_T	*itemlist = item->li_tv.vval.v_list;
+
+	    vimlist_remove(list, item, item);
+	    if (list_extend(list, itemlist, next) == FAIL)
+	    {
+		list_free_item(list, item);
+		return;
+	    }
+
+	    if (maxdepth > 0)
+		list_flatten(list, item->li_prev == NULL
+				     ? list->lv_first : item->li_prev->li_next,
+				itemlist->lv_len, maxdepth - 1);
+	    clear_tv(&item->li_tv);
+	    list_free_item(list, item);
+	}
+
+	++done;
+	item = next;
+    }
+}
+
+/*
+ * "flatten()" and "flattennew()" functions
+ */
+    static void
+flatten_common(typval_T *argvars, typval_T *rettv, int make_copy)
+{
+    list_T  *l;
+    long    maxdepth;
+    int	    error = FALSE;
+
+    if (in_vim9script()
+	    && (check_for_list_arg(argvars, 0) == FAIL
+		|| check_for_opt_number_arg(argvars, 1) == FAIL))
+	return;
+
+    if (argvars[0].v_type != VAR_LIST)
+    {
+	semsg(_(e_argument_of_str_must_be_list), "flatten()");
+	return;
+    }
+
+    if (argvars[1].v_type == VAR_UNKNOWN)
+	maxdepth = 999999;
+    else
+    {
+	maxdepth = (long)tv_get_number_chk(&argvars[1], &error);
+	if (error)
+	    return;
+	if (maxdepth < 0)
+	{
+	    emsg(_(e_maxdepth_must_be_non_negative_number));
+	    return;
+	}
+    }
+
+    l = argvars[0].vval.v_list;
+    rettv->v_type = VAR_LIST;
+    rettv->vval.v_list = l;
+    if (l == NULL)
+	return;
+
+    if (make_copy)
+    {
+	l = list_copy(l, FALSE, TRUE, get_copyID());
+	rettv->vval.v_list = l;
+	if (l == NULL)
+	    return;
+	// The type will change.
+	free_type(l->lv_type);
+	l->lv_type = NULL;
+    }
+    else
+    {
+	if (value_check_lock(l->lv_lock,
+				     (char_u *)N_("flatten() argument"), TRUE))
+	    return;
+	++l->lv_refcount;
+    }
+
+    list_flatten(l, NULL, l->lv_len, maxdepth);
+}
+
+/*
+ * "flatten(list[, {maxdepth}])" function
+ */
+    void
+f_flatten(typval_T *argvars, typval_T *rettv)
+{
+    if (in_vim9script())
+	emsg(_(e_cannot_use_flatten_in_vim9_script));
+    else
+	flatten_common(argvars, rettv, FALSE);
+}
+
+/*
+ * "flattennew(list[, {maxdepth}])" function
+ */
+    void
+f_flattennew(typval_T *argvars, typval_T *rettv)
+{
+    flatten_common(argvars, rettv, TRUE);
+}
+
+/*
+ * "items(list)" function
+ * Caller must have already checked that argvars[0] is a List.
+ */
+    void
+list2items(typval_T *argvars, typval_T *rettv)
+{
+    list_T	*l = argvars[0].vval.v_list;
+    listitem_T	*li;
+    varnumber_T	idx;
+
+    if (rettv_list_alloc(rettv) == FAIL)
+	return;
+    if (l == NULL)
+	return;  // null list behaves like an empty list
+
+    // TODO: would be more efficient to not materialize the argument
+    CHECK_LIST_MATERIALIZE(l);
+    for (idx = 0, li = l->lv_first; li != NULL; li = li->li_next, ++idx)
+    {
+	list_T	    *l2 = list_alloc();
+
+	if (l2 == NULL)
+	    break;
+	if (list_append_list(rettv->vval.v_list, l2) == FAIL)
+	{
+	    vim_free(l2);
+	    break;
+	}
+	if (list_append_number(l2, idx) == FAIL
+		|| list_append_tv(l2, &li->li_tv) == FAIL)
+	    break;
+    }
+}
+
+/*
+ * "items(string)" function
+ * Caller must have already checked that argvars[0] is a String.
+ */
+    void
+string2items(typval_T *argvars, typval_T *rettv)
+{
+    char_u	*p = argvars[0].vval.v_string;
+    varnumber_T idx;
+
+    if (rettv_list_alloc(rettv) == FAIL)
+	return;
+    if (p == NULL)
+	return;  // null string behaves like an empty string
+
+    for (idx = 0; *p != NUL; ++idx)
+    {
+	int	    len = mb_ptr2len(p);
+	list_T	    *l2;
+
+	if (len == 0)
+	    break;
+	l2 = list_alloc();
+	if (l2 == NULL)
+	    break;
+	if (list_append_list(rettv->vval.v_list, l2) == FAIL)
+	{
+	    vim_free(l2);
+	    break;
+	}
+	if (list_append_number(l2, idx) == FAIL
+		|| list_append_string(l2, p, len) == FAIL)
+	    break;
+	p += len;
+    }
+}
+
+/*
+ * Extend "l1" with "l2".  "l1" must not be NULL.
+ * If "bef" is NULL append at the end, otherwise insert before this item.
+ * Returns FAIL when out of memory.
+ */
+    int
+list_extend(list_T *l1, list_T *l2, listitem_T *bef)
+{
+    listitem_T	*item;
+    int		todo;
+    listitem_T	*bef_prev;
+
+    // NULL list is equivalent to an empty list: nothing to do.
+    if (l2 == NULL || l2->lv_len == 0)
+	return OK;
+
+    todo = l2->lv_len;
+    CHECK_LIST_MATERIALIZE(l1);
+    CHECK_LIST_MATERIALIZE(l2);
+
+    // When exending a list with itself, at some point we run into the item
+    // that was before "bef" and need to skip over the already inserted items
+    // to "bef".
+    bef_prev = bef == NULL ? NULL : bef->li_prev;
+
+    // We also quit the loop when we have inserted the original item count of
+    // the list, avoid a hang when we extend a list with itself.
+    for (item = l2->lv_first; item != NULL && --todo >= 0;
+				 item = item == bef_prev ? bef : item->li_next)
+	if (list_insert_tv(l1, &item->li_tv, bef) == FAIL)
+	    return FAIL;
+    return OK;
+}
+
+/*
+ * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
+ * Return FAIL when out of memory.
+ */
+    int
+list_concat(list_T *l1, list_T *l2, typval_T *tv)
+{
+    list_T	*l;
+
+    // make a copy of the first list.
+    if (l1 == NULL)
+	l = list_alloc();
+    else
+	l = list_copy(l1, FALSE, TRUE, 0);
+    if (l == NULL)
+	return FAIL;
+    tv->v_type = VAR_LIST;
+    tv->v_lock = 0;
+    tv->vval.v_list = l;
+    if (l1 == NULL)
+	++l->lv_refcount;
+
+    // append all items from the second list
+    return list_extend(l, l2, NULL);
+}
+
+    list_T *
+list_slice(list_T *ol, long n1, long n2)
+{
+    listitem_T	*item;
+    list_T	*l = list_alloc();
+
+    if (l == NULL)
+	return NULL;
+    for (item = list_find(ol, n1); n1 <= n2; ++n1)
+    {
+	if (list_append_tv(l, &item->li_tv) == FAIL)
+	{
+	    list_free(l);
+	    return NULL;
+	}
+	item = item->li_next;
+    }
+    return l;
+}
+
+    int
+list_slice_or_index(
+	    list_T	*list,
+	    int		range,
+	    varnumber_T	n1_arg,
+	    varnumber_T	n2_arg,
+	    int		exclusive,
+	    typval_T	*rettv,
+	    int		verbose)
+{
+    long	len = list_len(list);
+    varnumber_T	n1 = n1_arg;
+    varnumber_T	n2 = n2_arg;
+    typval_T	var1;
+
+    if (n1 < 0)
+	n1 = len + n1;
+    if (n1 < 0 || n1 >= len)
+    {
+	// For a range we allow invalid values and for legacy script return an
+	// empty list, for Vim9 script start at the first item.
+	// A list index out of range is an error.
+	if (!range)
+	{
+	    if (verbose)
+		semsg(_(e_list_index_out_of_range_nr), (long)n1_arg);
+	    return FAIL;
+	}
+	if (in_vim9script())
+	    n1 = n1 < 0 ? 0 : len;
+	else
+	    n1 = len;
+    }
+    if (range)
+    {
+	list_T	*l;
+
+	if (n2 < 0)
+	    n2 = len + n2;
+	else if (n2 >= len)
+	    n2 = len - (exclusive ? 0 : 1);
+	if (exclusive)
+	    --n2;
+	if (n2 < 0 || n2 + 1 < n1)
+	    n2 = -1;
+	l = list_slice(list, n1, n2);
+	if (l == NULL)
+	    return FAIL;
+	clear_tv(rettv);
+	rettv_list_set(rettv, l);
+    }
+    else
+    {
+	// copy the item to "var1" to avoid that freeing the list makes it
+	// invalid.
+	copy_tv(&list_find(list, n1)->li_tv, &var1);
+	clear_tv(rettv);
+	*rettv = var1;
+    }
+    return OK;
+}
+
+/*
+ * Make a copy of list "orig".  Shallow if "deep" is FALSE.
+ * The refcount of the new list is set to 1.
+ * See item_copy() for "top" and "copyID".
+ * Returns NULL when out of memory.
+ */
+    list_T *
+list_copy(list_T *orig, int deep, int top, int copyID)
+{
+    list_T	*copy;
+    listitem_T	*item;
+    listitem_T	*ni;
+
+    if (orig == NULL)
+	return NULL;
+
+    copy = list_alloc();
+    if (copy == NULL)
+	return NULL;
+
+    if (orig->lv_type == NULL || top || deep)
+	copy->lv_type = NULL;
+    else
+	copy->lv_type = alloc_type(orig->lv_type);
+    if (copyID != 0)
+    {
+	// Do this before adding the items, because one of the items may
+	// refer back to this list.
+	orig->lv_copyID = copyID;
+	orig->lv_copylist = copy;
+    }
+    CHECK_LIST_MATERIALIZE(orig);
+    for (item = orig->lv_first; item != NULL && !got_int;
+	    item = item->li_next)
+    {
+	ni = listitem_alloc();
+	if (ni == NULL)
+	    break;
+	if (deep)
+	{
+	    if (item_copy(&item->li_tv, &ni->li_tv,
+			deep, FALSE, copyID) == FAIL)
+	    {
+		vim_free(ni);
+		break;
+	    }
+	}
+	else
+	    copy_tv(&item->li_tv, &ni->li_tv);
+	list_append(copy, ni);
+    }
+    ++copy->lv_refcount;
+    if (item != NULL)
+    {
+	list_unref(copy);
+	copy = NULL;
+    }
+
+    return copy;
+}
+
+/*
+ * Remove items "item" to "item2" from list "l".
+ * Does not free the listitem or the value!
+ * This used to be called list_remove, but that conflicts with a Sun header
+ * file.
+ */
+    void
+vimlist_remove(list_T *l, listitem_T *item, listitem_T *item2)
+{
+    listitem_T	*ip;
+
+    CHECK_LIST_MATERIALIZE(l);
+
+    // notify watchers
+    for (ip = item; ip != NULL; ip = ip->li_next)
+    {
+	--l->lv_len;
+	list_fix_watch(l, ip);
+	if (ip == item2)
+	    break;
+    }
+
+    if (item2->li_next == NULL)
+	l->lv_u.mat.lv_last = item->li_prev;
+    else
+	item2->li_next->li_prev = item->li_prev;
+    if (item->li_prev == NULL)
+	l->lv_first = item2->li_next;
+    else
+	item->li_prev->li_next = item2->li_next;
+    l->lv_u.mat.lv_idx_item = NULL;
+}
+
+/*
+ * Return an allocated string with the string representation of a list.
+ * May return NULL.
+ */
+    char_u *
+list2string(typval_T *tv, int copyID, int restore_copyID)
+{
+    garray_T	ga;
+
+    if (tv->vval.v_list == NULL)
+	return NULL;
+    ga_init2(&ga, sizeof(char), 80);
+    ga_append(&ga, '[');
+    CHECK_LIST_MATERIALIZE(tv->vval.v_list);
+    if (list_join(&ga, tv->vval.v_list, (char_u *)", ",
+				       FALSE, restore_copyID, copyID) == FAIL)
+    {
+	vim_free(ga.ga_data);
+	return NULL;
+    }
+    ga_append(&ga, ']');
+    ga_append(&ga, NUL);
+    return (char_u *)ga.ga_data;
+}
+
+typedef struct join_S {
+    char_u	*s;
+    char_u	*tofree;
+} join_T;
+
+    static int
+list_join_inner(
+    garray_T	*gap,		// to store the result in
+    list_T	*l,
+    char_u	*sep,
+    int		echo_style,
+    int		restore_copyID,
+    int		copyID,
+    garray_T	*join_gap)	// to keep each list item string
+{
+    int		i;
+    join_T	*p;
+    int		len;
+    int		sumlen = 0;
+    int		first = TRUE;
+    char_u	*tofree;
+    char_u	numbuf[NUMBUFLEN];
+    listitem_T	*item;
+    char_u	*s;
+
+    // Stringify each item in the list.
+    CHECK_LIST_MATERIALIZE(l);
+    for (item = l->lv_first; item != NULL && !got_int; item = item->li_next)
+    {
+	s = echo_string_core(&item->li_tv, &tofree, numbuf, copyID,
+				      echo_style, restore_copyID, !echo_style);
+	if (s == NULL)
+	    return FAIL;
+
+	len = (int)STRLEN(s);
+	sumlen += len;
+
+	(void)ga_grow(join_gap, 1);
+	p = ((join_T *)join_gap->ga_data) + (join_gap->ga_len++);
+	if (tofree != NULL || s != numbuf)
+	{
+	    p->s = s;
+	    p->tofree = tofree;
+	}
+	else
+	{
+	    p->s = vim_strnsave(s, len);
+	    p->tofree = p->s;
+	}
+
+	line_breakcheck();
+	if (did_echo_string_emsg)  // recursion error, bail out
+	    break;
+    }
+
+    // Allocate result buffer with its total size, avoid re-allocation and
+    // multiple copy operations.  Add 2 for a tailing ']' and NUL.
+    if (join_gap->ga_len >= 2)
+	sumlen += (int)STRLEN(sep) * (join_gap->ga_len - 1);
+    if (ga_grow(gap, sumlen + 2) == FAIL)
+	return FAIL;
+
+    for (i = 0; i < join_gap->ga_len && !got_int; ++i)
+    {
+	if (first)
+	    first = FALSE;
+	else
+	    ga_concat(gap, sep);
+	p = ((join_T *)join_gap->ga_data) + i;
+
+	if (p->s != NULL)
+	    ga_concat(gap, p->s);
+	line_breakcheck();
+    }
+
+    return OK;
+}
+
+/*
+ * Join list "l" into a string in "*gap", using separator "sep".
+ * When "echo_style" is TRUE use String as echoed, otherwise as inside a List.
+ * Return FAIL or OK.
+ */
+    int
+list_join(
+    garray_T	*gap,
+    list_T	*l,
+    char_u	*sep,
+    int		echo_style,
+    int		restore_copyID,
+    int		copyID)
+{
+    garray_T	join_ga;
+    int		retval;
+    join_T	*p;
+    int		i;
+
+    if (l->lv_len < 1)
+	return OK; // nothing to do
+    ga_init2(&join_ga, sizeof(join_T), l->lv_len);
+    retval = list_join_inner(gap, l, sep, echo_style, restore_copyID,
+							    copyID, &join_ga);
+
+    if (join_ga.ga_data == NULL)
+	return retval;
+
+    // Dispose each item in join_ga.
+    p = (join_T *)join_ga.ga_data;
+    for (i = 0; i < join_ga.ga_len; ++i)
+    {
+	vim_free(p->tofree);
+	++p;
+    }
+    ga_clear(&join_ga);
+
+    return retval;
+}
+
+/*
+ * "join()" function
+ */
+    void
+f_join(typval_T *argvars, typval_T *rettv)
+{
+    garray_T	ga;
+    char_u	*sep;
+
+    rettv->v_type = VAR_STRING;
+
+    if (in_vim9script()
+	    && (check_for_list_arg(argvars, 0) == FAIL
+		|| check_for_opt_string_arg(argvars, 1) == FAIL))
+	return;
+
+    if (check_for_list_arg(argvars, 0) == FAIL)
+	return;
+
+    if (argvars[0].vval.v_list == NULL)
+	return;
+
+    if (argvars[1].v_type == VAR_UNKNOWN)
+	sep = (char_u *)" ";
+    else
+	sep = tv_get_string_chk(&argvars[1]);
+
+    if (sep != NULL)
+    {
+	ga_init2(&ga, sizeof(char), 80);
+	list_join(&ga, argvars[0].vval.v_list, sep, TRUE, FALSE, 0);
+	ga_append(&ga, NUL);
+	rettv->vval.v_string = (char_u *)ga.ga_data;
+    }
+    else
+	rettv->vval.v_string = NULL;
+}
+
+/*
+ * Allocate a variable for a List and fill it from "*arg".
+ * "*arg" points to the "[".
+ * Return OK or FAIL.
+ */
+    int
+eval_list(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int do_error)
+{
+    int		evaluate = evalarg == NULL ? FALSE
+					 : evalarg->eval_flags & EVAL_EVALUATE;
+    list_T	*l = NULL;
+    typval_T	tv;
+    listitem_T	*item;
+    int		vim9script = in_vim9script();
+    int		had_comma;
+
+    if (evaluate)
+    {
+	l = list_alloc();
+	if (l == NULL)
+	    return FAIL;
+    }
+
+    *arg = skipwhite_and_linebreak(*arg + 1, evalarg);
+    while (**arg != ']' && **arg != NUL)
+    {
+	if (eval1(arg, &tv, evalarg) == FAIL)	// recursive!
+	    goto failret;
+	if (check_typval_is_value(&tv) == FAIL)
+	{
+	    if (evaluate)
+		clear_tv(&tv);
+	    goto failret;
+	}
+	if (evaluate)
+	{
+	    item = listitem_alloc();
+	    if (item != NULL)
+	    {
+		item->li_tv = tv;
+		item->li_tv.v_lock = 0;
+		list_append(l, item);
+	    }
+	    else
+		clear_tv(&tv);
+	}
+	// Legacy Vim script allowed a space before the comma.
+	if (!vim9script)
+	    *arg = skipwhite(*arg);
+
+	// the comma must come after the value
+	had_comma = **arg == ',';
+	if (had_comma)
+	{
+	    if (vim9script && !IS_WHITE_NL_OR_NUL((*arg)[1]) && (*arg)[1] != ']')
+	    {
+		semsg(_(e_white_space_required_after_str_str), ",", *arg);
+		goto failret;
+	    }
+	    *arg = skipwhite(*arg + 1);
+	}
+
+	// The "]" can be on the next line.  But a double quoted string may
+	// follow, not a comment.
+	*arg = skipwhite_and_linebreak(*arg, evalarg);
+	if (**arg == ']')
+	    break;
+
+	if (!had_comma)
+	{
+	    if (do_error)
+	    {
+		if (**arg == ',')
+		    semsg(_(e_no_white_space_allowed_before_str_str),
+								    ",", *arg);
+		else
+		    semsg(_(e_missing_comma_in_list_str), *arg);
+	    }
+	    goto failret;
+	}
+    }
+
+    if (**arg != ']')
+    {
+	if (do_error)
+	    semsg(_(e_missing_end_of_list_rsb_str), *arg);
+failret:
+	if (evaluate)
+	    list_free(l);
+	return FAIL;
+    }
+
+    *arg += 1;
+    if (evaluate)
+	rettv_list_set(rettv, l);
+
+    return OK;
+}
+
+/*
+ * Write "list" of strings to file "fd".
+ */
+    int
+write_list(FILE *fd, list_T *list, int binary)
+{
+    listitem_T	*li;
+    int		c;
+    int		ret = OK;
+    char_u	*s;
+
+    CHECK_LIST_MATERIALIZE(list);
+    FOR_ALL_LIST_ITEMS(list, li)
+    {
+	for (s = tv_get_string(&li->li_tv); *s != NUL; ++s)
+	{
+	    if (*s == '\n')
+		c = putc(NUL, fd);
+	    else
+		c = putc(*s, fd);
+	    if (c == EOF)
+	    {
+		ret = FAIL;
+		break;
+	    }
+	}
+	if (!binary || li->li_next != NULL)
+	    if (putc('\n', fd) == EOF)
+	    {
+		ret = FAIL;
+		break;
+	    }
+	if (ret == FAIL)
+	{
+	    emsg(_(e_error_while_writing));
+	    break;
+	}
+    }
+    return ret;
+}
+
+/*
+ * Initialize a static list with 10 items.
+ */
+    void
+init_static_list(staticList10_T *sl)
+{
+    list_T  *l = &sl->sl_list;
+    int	    i;
+
+    CLEAR_POINTER(sl);
+    l->lv_first = &sl->sl_items[0];
+    l->lv_u.mat.lv_last = &sl->sl_items[9];
+    l->lv_refcount = DO_NOT_FREE_CNT;
+    l->lv_lock = VAR_FIXED;
+    sl->sl_list.lv_len = 10;
+
+    for (i = 0; i < 10; ++i)
+    {
+	listitem_T *li = &sl->sl_items[i];
+
+	if (i == 0)
+	    li->li_prev = NULL;
+	else
+	    li->li_prev = li - 1;
+	if (i == 9)
+	    li->li_next = NULL;
+	else
+	    li->li_next = li + 1;
+    }
+}
+
+/*
+ * "list2str()" function
+ */
+    void
+f_list2str(typval_T *argvars, typval_T *rettv)
+{
+    list_T	*l;
+    listitem_T	*li;
+    garray_T	ga;
+    int		utf8 = FALSE;
+
+    rettv->v_type = VAR_STRING;
+    rettv->vval.v_string = NULL;
+
+    if (in_vim9script()
+	    && (check_for_list_arg(argvars, 0) == FAIL
+		|| check_for_opt_bool_arg(argvars, 1) == FAIL))
+	return;
+
+    if (check_for_list_arg(argvars, 0) == FAIL)
+	return;
+
+    l = argvars[0].vval.v_list;
+    if (l == NULL)
+	return;  // empty list results in empty string
+
+    if (argvars[1].v_type != VAR_UNKNOWN)
+	utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
+
+    CHECK_LIST_MATERIALIZE(l);
+    ga_init2(&ga, 1, 80);
+    if (has_mbyte || utf8)
+    {
+	char_u	buf[MB_MAXBYTES + 1];
+	int	(*char2bytes)(int, char_u *);
+
+	if (utf8 || enc_utf8)
+	    char2bytes = utf_char2bytes;
+	else
+	    char2bytes = mb_char2bytes;
+
+	FOR_ALL_LIST_ITEMS(l, li)
+	{
+	    buf[(*char2bytes)(tv_get_number(&li->li_tv), buf)] = NUL;
+	    ga_concat(&ga, buf);
+	}
+	ga_append(&ga, NUL);
+    }
+    else if (ga_grow(&ga, list_len(l) + 1) == OK)
+    {
+	FOR_ALL_LIST_ITEMS(l, li)
+	    ga_append(&ga, tv_get_number(&li->li_tv));
+	ga_append(&ga, NUL);
+    }
+
+    rettv->v_type = VAR_STRING;
+    rettv->vval.v_string = ga.ga_data;
+}
+
+/*
+ * Remove item argvars[1] from List argvars[0]. If argvars[2] is supplied, then
+ * remove the range of items from argvars[1] to argvars[2] (inclusive).
+ */
+    static void
+list_remove(typval_T *argvars, typval_T *rettv, char_u *arg_errmsg)
+{
+    list_T	*l;
+    listitem_T	*item, *item2;
+    listitem_T	*li;
+    int		error = FALSE;
+    long	idx;
+    long	end;
+    int		cnt = 0;
+    list_T	*rl;
+
+    if ((l = argvars[0].vval.v_list) == NULL
+			     || value_check_lock(l->lv_lock, arg_errmsg, TRUE))
+	return;
+
+    idx = (long)tv_get_number_chk(&argvars[1], &error);
+    if (error)
+	return;		// type error: do nothing, errmsg already given
+
+    if ((item = list_find(l, idx)) == NULL)
+    {
+	semsg(_(e_list_index_out_of_range_nr), idx);
+	return;
+    }
+
+    if (argvars[2].v_type == VAR_UNKNOWN)
+    {
+	// Remove one item, return its value.
+	vimlist_remove(l, item, item);
+	*rettv = item->li_tv;
+	list_free_item(l, item);
+	return;
+    }
+
+    // Remove range of items, return list with values.
+    end = (long)tv_get_number_chk(&argvars[2], &error);
+    if (error)
+	return;		// type error: do nothing
+
+    if ((item2 = list_find(l, end)) == NULL)
+    {
+	semsg(_(e_list_index_out_of_range_nr), end);
+	return;
+    }
+
+    for (li = item; li != NULL; li = li->li_next)
+    {
+	++cnt;
+	if (li == item2)
+	    break;
+    }
+    if (li == NULL)  // didn't find "item2" after "item"
+    {
+	emsg(_(e_invalid_range));
+	return;
+    }
+
+    vimlist_remove(l, item, item2);
+    if (rettv_list_alloc(rettv) == FAIL)
+	return;
+
+    rl = rettv->vval.v_list;
+
+    if (l->lv_with_items > 0)
+    {
+	// need to copy the list items and move the value
+	while (item != NULL)
+	{
+	    li = listitem_alloc();
+	    if (li == NULL)
+		return;
+	    li->li_tv = item->li_tv;
+	    init_tv(&item->li_tv);
+	    list_append(rl, li);
+	    if (item == item2)
+		break;
+	    item = item->li_next;
+	}
+    }
+    else
+    {
+	rl->lv_first = item;
+	rl->lv_u.mat.lv_last = item2;
+	item->li_prev = NULL;
+	item2->li_next = NULL;
+	rl->lv_len = cnt;
+    }
+}
+
+static int item_compare(const void *s1, const void *s2);
+static int item_compare2(const void *s1, const void *s2);
+
+// struct used in the array that's given to qsort()
+typedef struct
+{
+    listitem_T	*item;
+    int		idx;
+} sortItem_T;
+
+// struct storing information about current sort
+typedef struct
+{
+    int		item_compare_ic;
+    int		item_compare_lc;
+    int		item_compare_numeric;
+    int		item_compare_numbers;
+    int		item_compare_float;
+    char_u	*item_compare_func;
+    partial_T	*item_compare_partial;
+    dict_T	*item_compare_selfdict;
+    int		item_compare_func_err;
+    int		item_compare_keep_zero;
+} sortinfo_T;
+static sortinfo_T	*sortinfo = NULL;
+#define ITEM_COMPARE_FAIL 999
+
+/*
+ * Compare functions for f_sort() and f_uniq() below.
+ */
+    static int
+item_compare(const void *s1, const void *s2)
+{
+    sortItem_T  *si1, *si2;
+    typval_T	*tv1, *tv2;
+    char_u	*p1, *p2;
+    char_u	*tofree1 = NULL, *tofree2 = NULL;
+    int		res;
+    char_u	numbuf1[NUMBUFLEN];
+    char_u	numbuf2[NUMBUFLEN];
+
+    si1 = (sortItem_T *)s1;
+    si2 = (sortItem_T *)s2;
+    tv1 = &si1->item->li_tv;
+    tv2 = &si2->item->li_tv;
+
+    if (sortinfo->item_compare_numbers)
+    {
+	varnumber_T	v1 = tv_to_number(tv1);
+	varnumber_T	v2 = tv_to_number(tv2);
+
+	return v1 == v2 ? 0 : v1 > v2 ? 1 : -1;
+    }
+
+    if (sortinfo->item_compare_float)
+    {
+	float_T	v1 = tv_get_float(tv1);
+	float_T	v2 = tv_get_float(tv2);
+
+	return v1 == v2 ? 0 : v1 > v2 ? 1 : -1;
+    }
+
+    // tv2string() puts quotes around a string and allocates memory.  Don't do
+    // that for string variables. Use a single quote when comparing with a
+    // non-string to do what the docs promise.
+    if (tv1->v_type == VAR_STRING)
+    {
+	if (tv2->v_type != VAR_STRING || sortinfo->item_compare_numeric)
+	    p1 = (char_u *)"'";
+	else
+	    p1 = tv1->vval.v_string;
+    }
+    else
+	p1 = tv2string(tv1, &tofree1, numbuf1, 0);
+    if (tv2->v_type == VAR_STRING)
+    {
+	if (tv1->v_type != VAR_STRING || sortinfo->item_compare_numeric)
+	    p2 = (char_u *)"'";
+	else
+	    p2 = tv2->vval.v_string;
+    }
+    else
+	p2 = tv2string(tv2, &tofree2, numbuf2, 0);
+    if (p1 == NULL)
+	p1 = (char_u *)"";
+    if (p2 == NULL)
+	p2 = (char_u *)"";
+    if (!sortinfo->item_compare_numeric)
+    {
+	if (sortinfo->item_compare_lc)
+	    res = strcoll((char *)p1, (char *)p2);
+	else
+	    res = sortinfo->item_compare_ic ? STRICMP(p1, p2): STRCMP(p1, p2);
+    }
+    else
+    {
+	double n1, n2;
+	n1 = strtod((char *)p1, (char **)&p1);
+	n2 = strtod((char *)p2, (char **)&p2);
+	res = n1 == n2 ? 0 : n1 > n2 ? 1 : -1;
+    }
+
+    // When the result would be zero, compare the item indexes.  Makes the
+    // sort stable.
+    if (res == 0 && !sortinfo->item_compare_keep_zero)
+	res = si1->idx > si2->idx ? 1 : -1;
+
+    vim_free(tofree1);
+    vim_free(tofree2);
+    return res;
+}
+
+    static int
+item_compare2(const void *s1, const void *s2)
+{
+    sortItem_T  *si1, *si2;
+    int		res;
+    typval_T	rettv;
+    typval_T	argv[3];
+    char_u	*func_name;
+    partial_T	*partial = sortinfo->item_compare_partial;
+    funcexe_T	funcexe;
+    int		did_emsg_before = did_emsg;
+
+    // shortcut after failure in previous call; compare all items equal
+    if (sortinfo->item_compare_func_err)
+	return 0;
+
+    si1 = (sortItem_T *)s1;
+    si2 = (sortItem_T *)s2;
+
+    if (partial == NULL)
+	func_name = sortinfo->item_compare_func;
+    else
+	func_name = partial_name(partial);
+
+    // Copy the values.  This is needed to be able to set v_lock to VAR_FIXED
+    // in the copy without changing the original list items.
+    copy_tv(&si1->item->li_tv, &argv[0]);
+    copy_tv(&si2->item->li_tv, &argv[1]);
+
+    rettv.v_type = VAR_UNKNOWN;		// clear_tv() uses this
+    CLEAR_FIELD(funcexe);
+    funcexe.fe_evaluate = TRUE;
+    funcexe.fe_partial = partial;
+    funcexe.fe_selfdict = sortinfo->item_compare_selfdict;
+    res = call_func(func_name, -1, &rettv, 2, argv, &funcexe);
+    clear_tv(&argv[0]);
+    clear_tv(&argv[1]);
+
+    if (res == FAIL || did_emsg > did_emsg_before)
+	res = ITEM_COMPARE_FAIL;
+    else
+    {
+	res = (int)tv_get_number_chk(&rettv, &sortinfo->item_compare_func_err);
+	if (res > 0)
+	    res = 1;
+	else if (res < 0)
+	    res = -1;
+    }
+    if (sortinfo->item_compare_func_err)
+	res = ITEM_COMPARE_FAIL;  // return value has wrong type
+    clear_tv(&rettv);
+
+    // When the result would be zero, compare the pointers themselves.  Makes
+    // the sort stable.
+    if (res == 0 && !sortinfo->item_compare_keep_zero)
+	res = si1->idx > si2->idx ? 1 : -1;
+
+    return res;
+}
+
+/*
+ * sort() List "l"
+ */
+    static void
+do_sort(list_T *l, sortinfo_T *info)
+{
+    long	len;
+    sortItem_T	*ptrs;
+    long	i = 0;
+    listitem_T	*li;
+
+    len = list_len(l);
+
+    // Make an array with each entry pointing to an item in the List.
+    ptrs = ALLOC_MULT(sortItem_T, len);
+    if (ptrs == NULL)
+	return;
+
+    // sort(): ptrs will be the list to sort
+    FOR_ALL_LIST_ITEMS(l, li)
+    {
+	ptrs[i].item = li;
+	ptrs[i].idx = i;
+	++i;
+    }
+
+    info->item_compare_func_err = FALSE;
+    info->item_compare_keep_zero = FALSE;
+    // test the compare function
+    if ((info->item_compare_func != NULL
+		|| info->item_compare_partial != NULL)
+	    && item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
+	    == ITEM_COMPARE_FAIL)
+	emsg(_(e_sort_compare_function_failed));
+    else
+    {
+	// Sort the array with item pointers.
+	qsort((void *)ptrs, (size_t)len, sizeof(sortItem_T),
+		info->item_compare_func == NULL
+		&& info->item_compare_partial == NULL
+		? item_compare : item_compare2);
+
+	if (!info->item_compare_func_err)
+	{
+	    // Clear the List and append the items in sorted order.
+	    l->lv_first = l->lv_u.mat.lv_last
+		= l->lv_u.mat.lv_idx_item = NULL;
+	    l->lv_len = 0;
+	    for (i = 0; i < len; ++i)
+		list_append(l, ptrs[i].item);
+	}
+    }
+
+    vim_free(ptrs);
+}
+
+/*
+ * uniq() List "l"
+ */
+    static void
+do_uniq(list_T *l, sortinfo_T *info)
+{
+    long	len;
+    sortItem_T	*ptrs;
+    long	i = 0;
+    listitem_T	*li;
+    int	(*item_compare_func_ptr)(const void *, const void *);
+
+    len = list_len(l);
+
+    // Make an array with each entry pointing to an item in the List.
+    ptrs = ALLOC_MULT(sortItem_T, len);
+    if (ptrs == NULL)
+	return;
+
+    // f_uniq(): ptrs will be a stack of items to remove
+    info->item_compare_func_err = FALSE;
+    info->item_compare_keep_zero = TRUE;
+    item_compare_func_ptr = info->item_compare_func != NULL
+	|| info->item_compare_partial != NULL
+	? item_compare2 : item_compare;
+
+    for (li = l->lv_first; li != NULL && li->li_next != NULL;
+	    li = li->li_next)
+    {
+	if (item_compare_func_ptr((void *)&li, (void *)&li->li_next)
+		== 0)
+	    ptrs[i++].item = li;
+	if (info->item_compare_func_err)
+	{
+	    emsg(_(e_uniq_compare_function_failed));
+	    break;
+	}
+    }
+
+    if (!info->item_compare_func_err)
+    {
+	while (--i >= 0)
+	{
+	    li = ptrs[i].item->li_next;
+	    ptrs[i].item->li_next = li->li_next;
+	    if (li->li_next != NULL)
+		li->li_next->li_prev = ptrs[i].item;
+	    else
+		l->lv_u.mat.lv_last = ptrs[i].item;
+	    list_fix_watch(l, li);
+	    listitem_free(l, li);
+	    l->lv_len--;
+	}
+    }
+
+    vim_free(ptrs);
+}
+
+/*
+ * Parse the optional arguments supplied to the sort() or uniq() function and
+ * return the values in "info".
+ */
+    static int
+parse_sort_uniq_args(typval_T *argvars, sortinfo_T *info)
+{
+    info->item_compare_ic = FALSE;
+    info->item_compare_lc = FALSE;
+    info->item_compare_numeric = FALSE;
+    info->item_compare_numbers = FALSE;
+    info->item_compare_float = FALSE;
+    info->item_compare_func = NULL;
+    info->item_compare_partial = NULL;
+    info->item_compare_selfdict = NULL;
+
+    if (argvars[1].v_type == VAR_UNKNOWN)
+	return OK;
+
+    // optional second argument: {func}
+    if (argvars[1].v_type == VAR_FUNC)
+	info->item_compare_func = argvars[1].vval.v_string;
+    else if (argvars[1].v_type == VAR_PARTIAL)
+	info->item_compare_partial = argvars[1].vval.v_partial;
+    else
+    {
+	int	    error = FALSE;
+	int	    nr = 0;
+
+	if (argvars[1].v_type == VAR_NUMBER)
+	{
+	    nr = tv_get_number_chk(&argvars[1], &error);
+	    if (error)
+		return FAIL;
+	    if (nr == 1)
+		info->item_compare_ic = TRUE;
+	}
+	if (nr != 1)
+	{
+	    if (argvars[1].v_type != VAR_NUMBER)
+		info->item_compare_func = tv_get_string(&argvars[1]);
+	    else if (nr != 0)
+	    {
+		emsg(_(e_invalid_argument));
+		return FAIL;
+	    }
+	}
+	if (info->item_compare_func != NULL)
+	{
+	    if (*info->item_compare_func == NUL)
+	    {
+		// empty string means default sort
+		info->item_compare_func = NULL;
+	    }
+	    else if (STRCMP(info->item_compare_func, "n") == 0)
+	    {
+		info->item_compare_func = NULL;
+		info->item_compare_numeric = TRUE;
+	    }
+	    else if (STRCMP(info->item_compare_func, "N") == 0)
+	    {
+		info->item_compare_func = NULL;
+		info->item_compare_numbers = TRUE;
+	    }
+	    else if (STRCMP(info->item_compare_func, "f") == 0)
+	    {
+		info->item_compare_func = NULL;
+		info->item_compare_float = TRUE;
+	    }
+	    else if (STRCMP(info->item_compare_func, "i") == 0)
+	    {
+		info->item_compare_func = NULL;
+		info->item_compare_ic = TRUE;
+	    }
+	    else if (STRCMP(info->item_compare_func, "l") == 0)
+	    {
+		info->item_compare_func = NULL;
+		info->item_compare_lc = TRUE;
+	    }
+	}
+    }
+
+    if (argvars[2].v_type != VAR_UNKNOWN)
+    {
+	// optional third argument: {dict}
+	if (check_for_dict_arg(argvars, 2) == FAIL)
+	    return FAIL;
+	info->item_compare_selfdict = argvars[2].vval.v_dict;
+    }
+
+    return OK;
+}
+
+/*
+ * "sort()" or "uniq()" function
+ */
+    static void
+do_sort_uniq(typval_T *argvars, typval_T *rettv, int sort)
+{
+    list_T	*l;
+    sortinfo_T	*old_sortinfo;
+    sortinfo_T	info;
+    long	len;
+
+    if (in_vim9script()
+	    && (check_for_list_arg(argvars, 0) == FAIL
+		|| (argvars[1].v_type != VAR_UNKNOWN
+		    && (check_for_string_or_func_arg(argvars, 1) == FAIL
+			      || check_for_opt_dict_arg(argvars, 2) == FAIL))))
+	return;
+
+    if (argvars[0].v_type != VAR_LIST)
+    {
+	semsg(_(e_argument_of_str_must_be_list), sort ? "sort()" : "uniq()");
+	return;
+    }
+
+    // Pointer to current info struct used in compare function. Save and
+    // restore the current one for nested calls.
+    old_sortinfo = sortinfo;
+    sortinfo = &info;
+
+    l = argvars[0].vval.v_list;
+    if (l != NULL && value_check_lock(l->lv_lock,
+		(char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),
+		TRUE))
+	goto theend;
+    rettv_list_set(rettv, l);
+    if (l == NULL)
+	goto theend;
+    CHECK_LIST_MATERIALIZE(l);
+
+    len = list_len(l);
+    if (len <= 1)
+	goto theend;	// short list sorts pretty quickly
+
+    if (parse_sort_uniq_args(argvars, &info) == FAIL)
+	goto theend;
+
+    if (sort)
+	do_sort(l, &info);
+    else
+	do_uniq(l, &info);
+
+theend:
+    sortinfo = old_sortinfo;
+}
+
+/*
+ * "sort({list})" function
+ */
+    void
+f_sort(typval_T *argvars, typval_T *rettv)
+{
+    do_sort_uniq(argvars, rettv, TRUE);
+}
+
+/*
+ * "uniq({list})" function
+ */
+    void
+f_uniq(typval_T *argvars, typval_T *rettv)
+{
+    do_sort_uniq(argvars, rettv, FALSE);
+}
+
+/*
+ * Handle one item for map() and filter().
+ * Sets v:val to "tv".  Caller must set v:key.
+ */
+    int
+filter_map_one(
+	typval_T	*tv,	    // original value
+	typval_T	*expr,	    // callback
+	filtermap_T	filtermap,
+	funccall_T	*fc,	    // from eval_expr_get_funccal()
+	typval_T	*newtv,	    // for map() and mapnew(): new value
+	int		*remp)	    // for filter(): remove flag
+{
+    typval_T	argv[3];
+    int		retval = FAIL;
+
+    copy_tv(tv, get_vim_var_tv(VV_VAL));
+    argv[0] = *get_vim_var_tv(VV_KEY);
+    argv[1] = *get_vim_var_tv(VV_VAL);
+    if (eval_expr_typval(expr, FALSE, argv, 2, fc, newtv) == FAIL)
+	goto theend;
+    if (filtermap == FILTERMAP_FILTER)
+    {
+	int	    error = FALSE;
+
+	// filter(): when expr is zero remove the item
+	if (in_vim9script())
+	    *remp = !tv_get_bool_chk(newtv, &error);
+	else
+	    *remp = (tv_get_number_chk(newtv, &error) == 0);
+	clear_tv(newtv);
+	// On type error, nothing has been removed; return FAIL to stop the
+	// loop.  The error message was given by tv_get_number_chk().
+	if (error)
+	    goto theend;
+    }
+    retval = OK;
+theend:
+    clear_tv(get_vim_var_tv(VV_VAL));
+    return retval;
+}
+
+/*
+ * Implementation of map() and filter() for a List.  Apply "expr" to every item
+ * in List "l" and return the result in "rettv".
+ */
+    static void
+list_filter_map(
+	list_T		*l,
+	filtermap_T	filtermap,
+	type_T		*argtype,
+	char		*func_name,
+	char_u		*arg_errmsg,
+	typval_T	*expr,
+	typval_T	*rettv)
+{
+    int		prev_lock;
+    list_T	*l_ret = NULL;
+    int		idx = 0;
+    int		rem;
+    listitem_T	*li, *nli;
+    typval_T	newtv;
+    funccall_T	*fc;
+
+    if (filtermap == FILTERMAP_MAPNEW)
+    {
+	rettv->v_type = VAR_LIST;
+	rettv->vval.v_list = NULL;
+    }
+    if (l == NULL || (filtermap == FILTERMAP_FILTER
+			    && value_check_lock(l->lv_lock, arg_errmsg, TRUE)))
+	return;
+
+    prev_lock = l->lv_lock;
+
+    if (filtermap == FILTERMAP_MAPNEW)
+    {
+	if (rettv_list_alloc(rettv) == FAIL)
+	    return;
+	l_ret = rettv->vval.v_list;
+    }
+    // set_vim_var_nr() doesn't set the type
+    set_vim_var_type(VV_KEY, VAR_NUMBER);
+
+    if (l->lv_lock == 0)
+	l->lv_lock = VAR_LOCKED;
+
+    // Create one funccall_T for all eval_expr_typval() calls.
+    fc = eval_expr_get_funccal(expr, &newtv);
+
+    if (l->lv_first == &range_list_item)
+    {
+	varnumber_T	val = l->lv_u.nonmat.lv_start;
+	int		len = l->lv_len;
+	int		stride = l->lv_u.nonmat.lv_stride;
+
+	// List from range(): loop over the numbers
+	if (filtermap != FILTERMAP_MAPNEW)
+	{
+	    l->lv_first = NULL;
+	    l->lv_u.mat.lv_last = NULL;
+	    l->lv_len = 0;
+	    l->lv_u.mat.lv_idx_item = NULL;
+	}
+
+	for (idx = 0; idx < len; ++idx)
+	{
+	    typval_T tv;
+
+	    tv.v_type = VAR_NUMBER;
+	    tv.v_lock = 0;
+	    tv.vval.v_number = val;
+	    set_vim_var_nr(VV_KEY, idx);
+	    if (filter_map_one(&tv, expr, filtermap, fc, &newtv, &rem) == FAIL)
+		break;
+	    if (did_emsg)
+	    {
+		clear_tv(&newtv);
+		break;
+	    }
+	    if (filtermap != FILTERMAP_FILTER)
+	    {
+		if (filtermap == FILTERMAP_MAP && argtype != NULL
+			&& check_typval_arg_type(
+			    argtype->tt_member, &newtv,
+			    func_name, 0) == FAIL)
+		{
+		    clear_tv(&newtv);
+		    break;
+		}
+		// map(), mapnew(): always append the new value to the
+		// list
+		if (list_append_tv_move(filtermap == FILTERMAP_MAP
+			    ? l : l_ret, &newtv) == FAIL)
+		    break;
+	    }
+	    else if (!rem)
+	    {
+		// filter(): append the list item value when not rem
+		if (list_append_tv_move(l, &tv) == FAIL)
+		    break;
+	    }
+
+	    val += stride;
+	}
+    }
+    else
+    {
+	// Materialized list: loop over the items
+	for (li = l->lv_first; li != NULL; li = nli)
+	{
+	    if (filtermap == FILTERMAP_MAP && value_check_lock(
+			li->li_tv.v_lock, arg_errmsg, TRUE))
+		break;
+	    nli = li->li_next;
+	    set_vim_var_nr(VV_KEY, idx);
+	    if (filter_map_one(&li->li_tv, expr, filtermap, fc,
+							 &newtv, &rem) == FAIL)
+		break;
+	    if (did_emsg)
+	    {
+		clear_tv(&newtv);
+		break;
+	    }
+	    if (filtermap == FILTERMAP_MAP)
+	    {
+		if (argtype != NULL && check_typval_arg_type(
+			    argtype->tt_member, &newtv, func_name, 0) == FAIL)
+		{
+		    clear_tv(&newtv);
+		    break;
+		}
+		// map(): replace the list item value
+		clear_tv(&li->li_tv);
+		newtv.v_lock = 0;
+		li->li_tv = newtv;
+	    }
+	    else if (filtermap == FILTERMAP_MAPNEW)
+	    {
+		// mapnew(): append the list item value
+		if (list_append_tv_move(l_ret, &newtv) == FAIL)
+		    break;
+	    }
+	    else if (filtermap == FILTERMAP_FILTER && rem)
+		listitem_remove(l, li);
+	    ++idx;
+	}
+    }
+
+    l->lv_lock = prev_lock;
+    if (fc != NULL)
+	remove_funccal();
+}
+
+/*
+ * Implementation of map() and filter().
+ */
+    static void
+filter_map(typval_T *argvars, typval_T *rettv, filtermap_T filtermap)
+{
+    typval_T	*expr;
+    char	*func_name = filtermap == FILTERMAP_MAP ? "map()"
+				  : filtermap == FILTERMAP_MAPNEW ? "mapnew()"
+				  : "filter()";
+    char_u	*arg_errmsg = (char_u *)(filtermap == FILTERMAP_MAP
+							 ? N_("map() argument")
+				       : filtermap == FILTERMAP_MAPNEW
+						      ? N_("mapnew() argument")
+						    : N_("filter() argument"));
+    int		save_did_emsg;
+    type_T	*type = NULL;
+
+    // map() and filter() return the first argument, also on failure.
+    if (filtermap != FILTERMAP_MAPNEW && argvars[0].v_type != VAR_STRING)
+	copy_tv(&argvars[0], rettv);
+
+    if (in_vim9script()
+	    && (check_for_list_or_dict_or_blob_or_string_arg(argvars, 0)
+								== FAIL))
+	return;
+
+    if (filtermap == FILTERMAP_MAP && in_vim9script())
+    {
+	// Check that map() does not change the declared type of the list or
+	// dict.
+	if (argvars[0].v_type == VAR_DICT && argvars[0].vval.v_dict != NULL)
+	    type = argvars[0].vval.v_dict->dv_type;
+	else if (argvars[0].v_type == VAR_LIST
+					     && argvars[0].vval.v_list != NULL)
+	    type = argvars[0].vval.v_list->lv_type;
+    }
+
+    if (argvars[0].v_type != VAR_BLOB
+	    && argvars[0].v_type != VAR_LIST
+	    && argvars[0].v_type != VAR_DICT
+	    && argvars[0].v_type != VAR_STRING)
+    {
+	semsg(_(e_argument_of_str_must_be_list_string_dictionary_or_blob),
+								    func_name);
+	return;
+    }
+
+    // On type errors, the preceding call has already displayed an error
+    // message.  Avoid a misleading error message for an empty string that
+    // was not passed as argument.
+    expr = &argvars[1];
+    if (expr->v_type == VAR_UNKNOWN)
+	return;
+
+    typval_T	save_val;
+    typval_T	save_key;
+
+    prepare_vimvar(VV_VAL, &save_val);
+    prepare_vimvar(VV_KEY, &save_key);
+
+    // We reset "did_emsg" to be able to detect whether an error
+    // occurred during evaluation of the expression.
+    save_did_emsg = did_emsg;
+    did_emsg = FALSE;
+
+    if (argvars[0].v_type == VAR_DICT)
+	dict_filter_map(argvars[0].vval.v_dict, filtermap, type, func_name,
+						      arg_errmsg, expr, rettv);
+    else if (argvars[0].v_type == VAR_BLOB)
+	blob_filter_map(argvars[0].vval.v_blob, filtermap, expr,
+							    arg_errmsg, rettv);
+    else if (argvars[0].v_type == VAR_STRING)
+	string_filter_map(tv_get_string(&argvars[0]), filtermap, expr, rettv);
+    else // argvars[0].v_type == VAR_LIST
+	list_filter_map(argvars[0].vval.v_list, filtermap, type, func_name,
+						      arg_errmsg, expr, rettv);
+
+    restore_vimvar(VV_KEY, &save_key);
+    restore_vimvar(VV_VAL, &save_val);
+
+    did_emsg |= save_did_emsg;
+}
+
+/*
+ * "filter()" function
+ */
+    void
+f_filter(typval_T *argvars, typval_T *rettv)
+{
+    filter_map(argvars, rettv, FILTERMAP_FILTER);
+}
+
+/*
+ * "map()" function
+ */
+    void
+f_map(typval_T *argvars, typval_T *rettv)
+{
+    filter_map(argvars, rettv, FILTERMAP_MAP);
+}
+
+/*
+ * "mapnew()" function
+ */
+    void
+f_mapnew(typval_T *argvars, typval_T *rettv)
+{
+    filter_map(argvars, rettv, FILTERMAP_MAPNEW);
+}
+
+/*
+ * "add(list, item)" function
+ */
+    static void
+list_add(typval_T *argvars, typval_T *rettv)
+{
+    list_T	*l = argvars[0].vval.v_list;
+
+    if (l == NULL)
+    {
+	if (in_vim9script())
+	    emsg(_(e_cannot_add_to_null_list));
+    }
+    else if (!value_check_lock(l->lv_lock,
+		(char_u *)N_("add() argument"), TRUE)
+	    && list_append_tv(l, &argvars[1]) == OK)
+    {
+	copy_tv(&argvars[0], rettv);
+    }
+}
+
+/*
+ * "add(object, item)" function
+ */
+    void
+f_add(typval_T *argvars, typval_T *rettv)
+{
+    rettv->vval.v_number = 1; // Default: Failed
+
+    if (in_vim9script()
+	    && (check_for_list_or_blob_arg(argvars, 0) == FAIL
+		|| (argvars[0].v_type == VAR_BLOB
+		    && check_for_number_arg(argvars, 1) == FAIL)))
+	return;
+
+    if (argvars[0].v_type == VAR_LIST)
+	list_add(argvars, rettv);
+    else if (argvars[0].v_type == VAR_BLOB)
+	blob_add(argvars, rettv);
+    else
+	emsg(_(e_list_or_blob_required));
+}
+
+/*
+ * Count the number of times item "needle" occurs in List "l" starting at index
+ * "idx". Case is ignored if "ic" is TRUE.
+ */
+    static long
+list_count(list_T *l, typval_T *needle, long idx, int ic)
+{
+    long	n = 0;
+    listitem_T	*li;
+
+    if (l == NULL)
+	return 0;
+
+    CHECK_LIST_MATERIALIZE(l);
+
+    if (list_len(l) == 0)
+	return 0;
+
+    li = list_find(l, idx);
+    if (li == NULL)
+    {
+	semsg(_(e_list_index_out_of_range_nr), idx);
+	return 0;
+    }
+
+    for ( ; li != NULL; li = li->li_next)
+	if (tv_equal(&li->li_tv, needle, ic, FALSE))
+	    ++n;
+
+    return n;
+}
+
+/*
+ * "count()" function
+ */
+    void
+f_count(typval_T *argvars, typval_T *rettv)
+{
+    long	n = 0;
+    int		ic = FALSE;
+    int		error = FALSE;
+
+    if (in_vim9script()
+	    && (check_for_string_or_list_or_dict_arg(argvars, 0) == FAIL
+		|| check_for_opt_bool_arg(argvars, 2) == FAIL
+		|| (argvars[2].v_type != VAR_UNKNOWN
+		    && check_for_opt_number_arg(argvars, 3) == FAIL)))
+	return;
+
+    if (argvars[2].v_type != VAR_UNKNOWN)
+	ic = (int)tv_get_bool_chk(&argvars[2], &error);
+
+    if (!error && argvars[0].v_type == VAR_STRING)
+	n = string_count(argvars[0].vval.v_string,
+					tv_get_string_chk(&argvars[1]), ic);
+    else if (!error && argvars[0].v_type == VAR_LIST)
+    {
+	long idx = 0;
+
+	if (argvars[2].v_type != VAR_UNKNOWN
+		&& argvars[3].v_type != VAR_UNKNOWN)
+	    idx = (long)tv_get_number_chk(&argvars[3], &error);
+	if (!error)
+	    n = list_count(argvars[0].vval.v_list, &argvars[1], idx, ic);
+    }
+    else if (!error && argvars[0].v_type == VAR_DICT)
+    {
+	if (argvars[2].v_type != VAR_UNKNOWN
+		&& argvars[3].v_type != VAR_UNKNOWN)
+	    emsg(_(e_invalid_argument));
+	else
+	    n = dict_count(argvars[0].vval.v_dict, &argvars[1], ic);
+    }
+    else if (!error)
+	semsg(_(e_argument_of_str_must_be_list_string_or_dictionary),
+								    "count()");
+    rettv->vval.v_number = n;
+}
+
+/*
+ * extend() a List. Append List argvars[1] to List argvars[0] before index
+ * argvars[3] and return the resulting list in "rettv".  "is_new" is TRUE for
+ * extendnew().
+ */
+    static void
+list_extend_func(
+	typval_T	*argvars,
+	type_T		*type,
+	char		*func_name,
+	char_u		*arg_errmsg,
+	int		is_new,
+	typval_T	*rettv)
+{
+    list_T	*l1, *l2;
+    listitem_T	*item;
+    long	before;
+    int		error = FALSE;
+
+    l1 = argvars[0].vval.v_list;
+    if (l1 == NULL)
+    {
+	emsg(_(e_cannot_extend_null_list));
+	return;
+    }
+    l2 = argvars[1].vval.v_list;
+    if ((is_new || !value_check_lock(l1->lv_lock, arg_errmsg, TRUE))
+								 && l2 != NULL)
+    {
+	if (is_new)
+	{
+	    l1 = list_copy(l1, FALSE, TRUE, get_copyID());
+	    if (l1 == NULL)
+		return;
+	}
+
+	if (argvars[2].v_type != VAR_UNKNOWN)
+	{
+	    before = (long)tv_get_number_chk(&argvars[2], &error);
+	    if (error)
+		return;		// type error; errmsg already given
+
+	    if (before == l1->lv_len)
+		item = NULL;
+	    else
+	    {
+		item = list_find(l1, before);
+		if (item == NULL)
+		{
+		    semsg(_(e_list_index_out_of_range_nr), before);
+		    return;
+		}
+	    }
+	}
+	else
+	    item = NULL;
+	if (type != NULL && check_typval_arg_type(
+		    type, &argvars[1], func_name, 2) == FAIL)
+	    return;
+	list_extend(l1, l2, item);
+
+	if (is_new)
+	{
+	    rettv->v_type = VAR_LIST;
+	    rettv->vval.v_list = l1;
+	    rettv->v_lock = FALSE;
+	}
+	else
+	    copy_tv(&argvars[0], rettv);
+    }
+}
+
+/*
+ * "extend()" or "extendnew()" function.  "is_new" is TRUE for extendnew().
+ */
+    static void
+extend(typval_T *argvars, typval_T *rettv, char_u *arg_errmsg, int is_new)
+{
+    type_T	*type = NULL;
+    char	*func_name = is_new ? "extendnew()" : "extend()";
+
+    if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)
+    {
+	// Check that extend() does not change the type of the list if it was
+	// declared.
+	if (!is_new && in_vim9script() && argvars[0].vval.v_list != NULL)
+	    type = argvars[0].vval.v_list->lv_type;
+	list_extend_func(argvars, type, func_name, arg_errmsg, is_new, rettv);
+    }
+    else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)
+    {
+	// Check that extend() does not change the type of the dict if it was
+	// declared.
+	if (!is_new && in_vim9script() && argvars[0].vval.v_dict != NULL)
+	    type = argvars[0].vval.v_dict->dv_type;
+	dict_extend_func(argvars, type, func_name, arg_errmsg, is_new, rettv);
+    }
+    else
+	semsg(_(e_argument_of_str_must_be_list_or_dictionary), func_name);
+}
+
+/*
+ * "extend(list, list [, idx])" function
+ * "extend(dict, dict [, action])" function
+ */
+    void
+f_extend(typval_T *argvars, typval_T *rettv)
+{
+    char_u      *errmsg = (char_u *)N_("extend() argument");
+
+    extend(argvars, rettv, errmsg, FALSE);
+}
+
+/*
+ * "extendnew(list, list [, idx])" function
+ * "extendnew(dict, dict [, action])" function
+ */
+    void
+f_extendnew(typval_T *argvars, typval_T *rettv)
+{
+    char_u      *errmsg = (char_u *)N_("extendnew() argument");
+
+    extend(argvars, rettv, errmsg, TRUE);
+}
+
+    static void
+list_insert_func(typval_T *argvars, typval_T *rettv)
+{
+    list_T	*l = argvars[0].vval.v_list;
+    long	before = 0;
+    listitem_T	*item;
+    int		error = FALSE;
+
+    if (l == NULL)
+    {
+	if (in_vim9script())
+	    emsg(_(e_cannot_add_to_null_list));
+	return;
+    }
+
+    if (value_check_lock(l->lv_lock, (char_u *)N_("insert() argument"), TRUE))
+	return;
+
+    if (argvars[2].v_type != VAR_UNKNOWN)
+	before = (long)tv_get_number_chk(&argvars[2], &error);
+    if (error)
+	return;		// type error; errmsg already given
+
+    if (before == l->lv_len)
+	item = NULL;
+    else
+    {
+	item = list_find(l, before);
+	if (item == NULL)
+	{
+	    semsg(_(e_list_index_out_of_range_nr), before);
+	    l = NULL;
+	}
+    }
+    if (l != NULL)
+    {
+	(void)list_insert_tv(l, &argvars[1], item);
+	copy_tv(&argvars[0], rettv);
+    }
+}
+
+/*
+ * "insert()" function
+ */
+    void
+f_insert(typval_T *argvars, typval_T *rettv)
+{
+    if (in_vim9script()
+	    && (check_for_list_or_blob_arg(argvars, 0) == FAIL
+		|| (argvars[0].v_type == VAR_BLOB
+		    && check_for_number_arg(argvars, 1) == FAIL)
+		|| check_for_opt_number_arg(argvars, 2) == FAIL))
+	return;
+
+    if (argvars[0].v_type == VAR_BLOB)
+	blob_insert_func(argvars, rettv);
+    else if (argvars[0].v_type != VAR_LIST)
+	semsg(_(e_argument_of_str_must_be_list_or_blob), "insert()");
+    else
+	list_insert_func(argvars, rettv);
+}
+
+/*
+ * "remove()" function
+ */
+    void
+f_remove(typval_T *argvars, typval_T *rettv)
+{
+    char_u	*arg_errmsg = (char_u *)N_("remove() argument");
+
+    if (in_vim9script()
+	    && (check_for_list_or_dict_or_blob_arg(argvars, 0) == FAIL
+		|| ((argvars[0].v_type == VAR_LIST
+			|| argvars[0].v_type == VAR_BLOB)
+		    && (check_for_number_arg(argvars, 1) == FAIL
+			|| check_for_opt_number_arg(argvars, 2) == FAIL))
+		|| (argvars[0].v_type == VAR_DICT
+		    && check_for_string_or_number_arg(argvars, 1) == FAIL)))
+	return;
+
+    if (argvars[0].v_type == VAR_DICT)
+	dict_remove(argvars, rettv, arg_errmsg);
+    else if (argvars[0].v_type == VAR_BLOB)
+	blob_remove(argvars, rettv, arg_errmsg);
+    else if (argvars[0].v_type == VAR_LIST)
+	list_remove(argvars, rettv, arg_errmsg);
+    else
+	semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "remove()");
+}
+
+    static void
+list_reverse(list_T *l, typval_T *rettv)
+{
+    listitem_T	*li, *ni;
+
+    rettv_list_set(rettv, l);
+    if (l != NULL
+	    && !value_check_lock(l->lv_lock,
+		(char_u *)N_("reverse() argument"), TRUE))
+    {
+	if (l->lv_first == &range_list_item)
+	{
+	    varnumber_T new_start = l->lv_u.nonmat.lv_start
+		+ ((varnumber_T)l->lv_len - 1) * l->lv_u.nonmat.lv_stride;
+	    l->lv_u.nonmat.lv_end = new_start
+		- (l->lv_u.nonmat.lv_end - l->lv_u.nonmat.lv_start);
+	    l->lv_u.nonmat.lv_start = new_start;
+	    l->lv_u.nonmat.lv_stride = -l->lv_u.nonmat.lv_stride;
+	    return;
+	}
+	li = l->lv_u.mat.lv_last;
+	l->lv_first = l->lv_u.mat.lv_last = NULL;
+	l->lv_len = 0;
+	while (li != NULL)
+	{
+	    ni = li->li_prev;
+	    list_append(l, li);
+	    li = ni;
+	}
+	l->lv_u.mat.lv_idx = l->lv_len - l->lv_u.mat.lv_idx - 1;
+    }
+}
+
+/*
+ * "reverse({list})" function
+ */
+    void
+f_reverse(typval_T *argvars, typval_T *rettv)
+{
+    if (check_for_string_or_list_or_blob_arg(argvars, 0) == FAIL)
+	return;
+
+    if (argvars[0].v_type == VAR_BLOB)
+	blob_reverse(argvars[0].vval.v_blob, rettv);
+    else if (argvars[0].v_type == VAR_STRING)
+    {
+	rettv->v_type = VAR_STRING;
+	if (argvars[0].vval.v_string != NULL)
+	    rettv->vval.v_string = reverse_text(argvars[0].vval.v_string);
+	else
+	    rettv->vval.v_string = NULL;
+    }
+    else if (argvars[0].v_type == VAR_LIST)
+	list_reverse(argvars[0].vval.v_list, rettv);
+}
+
+/*
+ * Implementation of reduce() for list "argvars[0]", using the function "expr"
+ * starting with the optional initial value argvars[2] and return the result in
+ * "rettv".
+ */
+    static void
+list_reduce(
+	typval_T	*argvars,
+	typval_T	*expr,
+	typval_T	*rettv)
+{
+    list_T	*l = argvars[0].vval.v_list;
+    listitem_T  *li = NULL;
+    int		range_list;
+    int		range_idx = 0;
+    varnumber_T	range_val = 0;
+    typval_T	initial;
+    typval_T	argv[3];
+    int		r;
+    int		called_emsg_start = called_emsg;
+    int		prev_locked;
+    funccall_T	*fc;
+
+    // Using reduce on a range() uses "range_idx" and "range_val".
+    range_list = l != NULL && l->lv_first == &range_list_item;
+    if (range_list)
+	range_val = l->lv_u.nonmat.lv_start;
+
+    if (argvars[2].v_type == VAR_UNKNOWN)
+    {
+	if (l == NULL || l->lv_len == 0)
+	{
+	    semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "List");
+	    return;
+	}
+	if (range_list)
+	{
+	    initial.v_type = VAR_NUMBER;
+	    initial.vval.v_number = range_val;
+	    range_val += l->lv_u.nonmat.lv_stride;
+	    range_idx = 1;
+	}
+	else
+	{
+	    initial = l->lv_first->li_tv;
+	    li = l->lv_first->li_next;
+	}
+    }
+    else
+    {
+	initial = argvars[2];
+	if (l != NULL && !range_list)
+	    li = l->lv_first;
+    }
+    copy_tv(&initial, rettv);
+
+    if (l == NULL)
+	return;
+
+    // Create one funccall_T for all eval_expr_typval() calls.
+    fc = eval_expr_get_funccal(expr, rettv);
+
+    prev_locked = l->lv_lock;
+    l->lv_lock = VAR_FIXED;  // disallow the list changing here
+
+    while (range_list ? range_idx < l->lv_len : li != NULL)
+    {
+	argv[0] = *rettv;
+	rettv->v_type = VAR_UNKNOWN;
+
+	if (range_list)
+	{
+	    argv[1].v_type = VAR_NUMBER;
+	    argv[1].vval.v_number = range_val;
+	}
+	else
+	    argv[1] = li->li_tv;
+
+	r = eval_expr_typval(expr, TRUE, argv, 2, fc, rettv);
+
+	if (argv[0].v_type != VAR_NUMBER && argv[0].v_type != VAR_UNKNOWN)
+	    clear_tv(&argv[0]);
+	if (r == FAIL || called_emsg != called_emsg_start)
+	    break;
+
+	// advance to the next item
+	if (range_list)
+	{
+	    range_val += l->lv_u.nonmat.lv_stride;
+	    ++range_idx;
+	}
+	else
+	    li = li->li_next;
+    }
+
+    if (fc != NULL)
+	remove_funccal();
+
+    l->lv_lock = prev_locked;
+}
+
+/*
+ * "reduce(list, { accumulator, element -> value } [, initial])" function
+ * "reduce(blob, { accumulator, element -> value } [, initial])"
+ * "reduce(string, { accumulator, element -> value } [, initial])"
+ */
+    void
+f_reduce(typval_T *argvars, typval_T *rettv)
+{
+    char_u	*func_name;
+
+    if (in_vim9script()
+		   && check_for_string_or_list_or_blob_arg(argvars, 0) == FAIL)
+	return;
+
+    if (argvars[0].v_type != VAR_STRING
+	    && argvars[0].v_type != VAR_LIST
+	    && argvars[0].v_type != VAR_BLOB)
+    {
+	emsg(_(e_string_list_or_blob_required));
+	return;
+    }
+
+    if (argvars[1].v_type == VAR_FUNC)
+	func_name = argvars[1].vval.v_string;
+    else if (argvars[1].v_type == VAR_PARTIAL)
+	func_name = partial_name(argvars[1].vval.v_partial);
+    else
+	func_name = tv_get_string(&argvars[1]);
+    if (func_name == NULL || *func_name == NUL)
+    {
+	emsg(_(e_missing_function_argument));
+	return;
+    }
+
+    if (argvars[0].v_type == VAR_LIST)
+	list_reduce(argvars, &argvars[1], rettv);
+    else if (argvars[0].v_type == VAR_STRING)
+	string_reduce(argvars, &argvars[1], rettv);
+    else
+	blob_reduce(argvars, &argvars[1], rettv);
+}
+
+#endif // defined(FEAT_EVAL)