#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "nvim/ascii.h"
#include "nvim/charset.h"
#include "nvim/eval.h"
#include "nvim/eval/encode.h"
#include "nvim/eval/executor.h"
#include "nvim/eval/gc.h"
#include "nvim/eval/typval.h"
#include "nvim/eval/typval_encode.h"
#include "nvim/eval/userfunc.h"
#include "nvim/garray.h"
#include "nvim/gettext.h"
#include "nvim/globals.h"
#include "nvim/hashtab.h"
#include "nvim/lib/queue.h"
#include "nvim/lua/executor.h"
#include "nvim/macros.h"
#include "nvim/mbyte.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/pos.h"
#include "nvim/types.h"
#include "nvim/vim.h"
#include "nvim/misc1.h"
#include "nvim/os/fileio.h"
#include "nvim/eval/typval_encode.c.h"

Macros
#define	DICT_MAXNEST 100

#define	SL_SIZE ARRAY_SIZE(sl->sl_items)

#define	FREE_JOIN_TOFREE(join) xfree((join)->tofree)

#define	SWAP(a, b)

#define	TYPVAL_ENCODE_ALLOW_SPECIALS false

#define	TYPVAL_ENCODE_CONV_NIL(tv)

#define	TYPVAL_ENCODE_CONV_BOOL(tv, num)

#define	TYPVAL_ENCODE_CONV_NUMBER(tv, num)

#define	TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER(tv, num)

#define	TYPVAL_ENCODE_CONV_FLOAT(tv, flt)

#define	TYPVAL_ENCODE_CONV_STRING(tv, buf, len)

#define	TYPVAL_ENCODE_CONV_STR_STRING(tv, buf, len)

#define	TYPVAL_ENCODE_CONV_EXT_STRING(tv, buf, len, type)

#define	TYPVAL_ENCODE_CONV_BLOB(tv, blob, len)

#define	TYPVAL_ENCODE_CONV_FUNC_START(tv, fun)

#define	TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv, len)

#define	TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, len)

#define	TYPVAL_ENCODE_CONV_FUNC_END(tv) _nothing_conv_func_end(tv, copyID)

#define	TYPVAL_ENCODE_CONV_EMPTY_LIST(tv)

#define	TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, dict)

#define	TYPVAL_ENCODE_CONV_LIST_START(tv, len)

#define	TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START(tv, mpsv)

#define	TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(tv)

#define	TYPVAL_ENCODE_CONV_LIST_END(tv) _nothing_conv_list_end(tv)

#define	TYPVAL_ENCODE_CONV_DICT_START(tv, dict, len)

#define	TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, dict, mpsv)

#define	TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK(tv, dict)

#define	TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(tv, dict)

#define	TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict)

#define	TYPVAL_ENCODE_CONV_DICT_END(tv, dict)

#define	TYPVAL_ENCODE_CONV_RECURSE(val, conv_type)

#define	TYPVAL_ENCODE_SCOPE static

#define	TYPVAL_ENCODE_NAME nothing

#define	TYPVAL_ENCODE_FIRST_ARG_TYPE const void *const

#define	TYPVAL_ENCODE_FIRST_ARG_NAME ignored

#define	TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME

#define	CHANGE_LOCK(lock, var)

#define	FUNC_ERROR "E703: Using a Funcref as a Number"

#define	FUNC_ERROR "E729: using Funcref as a String"

Functions
listitem_T *	tv_list_item_remove (list_T const l, listitem_T const item) FUNC_ATTR_NONNULL_ALL

void	tv_list_watch_add (list_T const l, listwatch_T const lw) FUNC_ATTR_NONNULL_ALL

void	tv_list_watch_remove (list_T const l, listwatch_T const lwrem) FUNC_ATTR_NONNULL_ALL

void	tv_list_watch_fix (list_T const l, const listitem_T const item) FUNC_ATTR_NONNULL_ALL

list_T *	tv_list_alloc (const ptrdiff_t len) FUNC_ATTR_NONNULL_RET

void	tv_list_init_static10 (staticList10_T *const sl) FUNC_ATTR_NONNULL_ALL

void	tv_list_init_static (list_T *const l) FUNC_ATTR_NONNULL_ALL

void	tv_list_free_contents (list_T *const l) FUNC_ATTR_NONNULL_ALL

void	tv_list_free_list (list_T *const l) FUNC_ATTR_NONNULL_ALL

void	tv_list_free (list_T *const l) FUNC_ATTR_NONNULL_ALL

void	tv_list_unref (list_T *const l)

void	tv_list_drop_items (list_T const l, listitem_T const item, listitem_T *const item2) FUNC_ATTR_NONNULL_ALL

void	tv_list_remove_items (list_T const l, listitem_T const item, listitem_T *const item2) FUNC_ATTR_NONNULL_ALL
	Like tv_list_drop_items, but also frees all removed items. More...

void	tv_list_move_items (list_T const l, listitem_T const item, listitem_T const item2, list_T const tgt_l, const int cnt) FUNC_ATTR_NONNULL_ALL

void	tv_list_insert (list_T const l, listitem_T const ni, listitem_T *const item) FUNC_ATTR_NONNULL_ARG(1

int	tv_list_join (garray_T const gap, list_T const l, const char *const sep) FUNC_ATTR_NONNULL_ARG(1)

bool	tv_list_equal (list_T const l1, list_T const l2, const bool ic, const bool recursive) FUNC_ATTR_WARN_UNUSED_RESULT

void	tv_list_reverse (list_T *const l)

void	tv_list_item_sort (list_T const l, ListSortItem const ptrs, const ListSorter item_compare_func, bool *errp) FUNC_ATTR_NONNULL_ARG(3

void	if (len<=1)

	list_log (l, NULL, NULL, "sort")

	TV_LIST_ITER (l, li, { ptrs[i].item=li;ptrs[i].idx=i;i++;})

	qsort (ptrs,(size_t) len, sizeof(ListSortItem), item_compare_func)

	if (!(*errp))

listitem_T *	tv_list_find (list_T *const l, int n) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT

varnumber_T	tv_list_find_nr (list_T const l, const int n, bool const ret_error) FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_list_find_str (list_T *const l, const int n) FUNC_ATTR_WARN_UNUSED_RESULT

long	tv_list_idx_of_item (const list_T const l, const listitem_T const item) FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE

void	tv_dict_watcher_add (dict_T const dict, const char const key_pattern, const size_t key_pattern_len, Callback callback) FUNC_ATTR_NONNULL_ARG(2)

bool	tv_callback_equal (const Callback cb1, const Callback cb2) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

void	callback_free (Callback *callback) FUNC_ATTR_NONNULL_ALL
	Unref/free callback. More...

void	callback_put (Callback cb, typval_T tv) FUNC_ATTR_NONNULL_ALL
	Copy a callback into a typval_T. More...

void	callback_copy (Callback dest, Callback src) FUNC_ATTR_NONNULL_ALL

bool	tv_dict_watcher_remove (dict_T const dict, const char const key_pattern, const size_t key_pattern_len, Callback callback) FUNC_ATTR_NONNULL_ARG(2)

void	tv_dict_watcher_notify (dict_T const dict, const char const key, typval_T const newtv, typval_T const oldtv) FUNC_ATTR_NONNULL_ARG(1

	if (newtv)

	if (oldtv)

	QUEUE_FOREACH (w, &dict->watchers, { DictWatcher *watcher=tv_dict_watcher_node_data(w);if(!watcher->busy &&tv_dict_watcher_matches(watcher, key)) { rettv=TV_INITIAL_VALUE;watcher->busy=true;callback_call(&watcher->callback, 3, argv, &rettv);watcher->busy=false;tv_clear(&rettv);if(watcher->needs_free) { any_needs_free=true;} } }) if(any_needs_free)

	tv_dict_unref (dict)

	for (size_t i=1;i< ARRAY_SIZE(argv);i++)

dictitem_T *	tv_dict_item_alloc_len (const char *const key, const size_t key_len) FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC

dictitem_T *	tv_dict_item_alloc (const char *const key) FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC

void	tv_dict_item_free (dictitem_T *const item) FUNC_ATTR_NONNULL_ALL

dictitem_T *	tv_dict_item_copy (dictitem_T *const di) FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

void	tv_dict_item_remove (dict_T const dict, dictitem_T const item) FUNC_ATTR_NONNULL_ALL

dict_T *	tv_dict_alloc (void)

void	tv_dict_free_contents (dict_T *const d) FUNC_ATTR_NONNULL_ALL

void	tv_dict_free_dict (dict_T *const d) FUNC_ATTR_NONNULL_ALL

void	tv_dict_free (dict_T *const d) FUNC_ATTR_NONNULL_ALL

void	tv_dict_unref (dict_T *const d)

dictitem_T *	tv_dict_find (const dict_T const d, const char const key, const ptrdiff_t len) FUNC_ATTR_NONNULL_ARG(2) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT

int	tv_dict_get_tv (dict_T d, const char const key, typval_T *rettv)

varnumber_T	tv_dict_get_number (const dict_T const d, const char const key) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT

char **	tv_dict_to_env (dict_T *denv)

char *	tv_dict_get_string (const dict_T const d, const char const key, const bool save) FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_dict_get_string_buf (const dict_T const d, const char const key, char *const numbuf) FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_dict_get_string_buf_chk (const dict_T const d, const char const key, const ptrdiff_t key_len, char const numbuf, const char const def) FUNC_ATTR_WARN_UNUSED_RESULT

bool	tv_dict_get_callback (dict_T const d, const char const key, const ptrdiff_t key_len, Callback *const result) FUNC_ATTR_NONNULL_ARG(2

	if (di==NULL)

	if (!tv_is_func(di->di_tv) &&di->di_tv.v_type !=VAR_STRING)

int	tv_dict_add (dict_T const d, dictitem_T const item) FUNC_ATTR_NONNULL_ALL

int	tv_dict_add_list (dict_T const d, const char const key, const size_t key_len, list_T *const list) FUNC_ATTR_NONNULL_ALL

int	tv_dict_add_tv (dict_T d, const char key, const size_t key_len, typval_T *tv)

int	tv_dict_add_dict (dict_T const d, const char const key, const size_t key_len, dict_T *const dict) FUNC_ATTR_NONNULL_ALL

int	tv_dict_add_nr (dict_T const d, const char const key, const size_t key_len, const varnumber_T nr)

int	tv_dict_add_float (dict_T const d, const char const key, const size_t key_len, const float_T nr)

int	tv_dict_add_bool (dict_T const d, const char const key, const size_t key_len, BoolVarValue val)

int	tv_dict_add_str (dict_T const d, const char const key, const size_t key_len, const char *const val) FUNC_ATTR_NONNULL_ARG(1

int int	tv_dict_add_str_len (dict_T const d, const char const key, const size_t key_len, const char *const val, int len) FUNC_ATTR_NONNULL_ARG(1

int int	if (val !=NULL)

return	tv_dict_add_allocated_str (d, key, key_len, s)

int	tv_dict_add_allocated_str (dict_T const d, const char const key, const size_t key_len, char *const val) FUNC_ATTR_NONNULL_ARG(1

	if (tv_dict_add(d, item)==FAIL)

void	tv_dict_clear (dict_T *const d) FUNC_ATTR_NONNULL_ALL

void	tv_dict_extend (dict_T const d1, dict_T const d2, const char *const action) FUNC_ATTR_NONNULL_ALL

bool	tv_dict_equal (dict_T const d1, dict_T const d2, const bool ic, const bool recursive) FUNC_ATTR_WARN_UNUSED_RESULT

dict_T *	tv_dict_copy (const vimconv_T const conv, dict_T const orig, const bool deep, const int copyID)

void	tv_dict_set_keys_readonly (dict_T *const dict) FUNC_ATTR_NONNULL_ALL

blob_T *	tv_blob_alloc (void)

void	tv_blob_free (blob_T *const b) FUNC_ATTR_NONNULL_ALL

void	tv_blob_unref (blob_T *const b)

bool	tv_blob_equal (const blob_T const b1, const blob_T const b2) FUNC_ATTR_WARN_UNUSED_RESULT

list_T *	tv_list_alloc_ret (typval_T *const ret_tv, const ptrdiff_t len) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET

dict_T *	tv_dict_alloc_lock (VarLockStatus lock) FUNC_ATTR_NONNULL_RET

void	tv_dict_alloc_ret (typval_T *const ret_tv) FUNC_ATTR_NONNULL_ALL

void	tv_blob_alloc_ret (typval_T *const ret_tv) FUNC_ATTR_NONNULL_ALL

void	tv_blob_copy (typval_T const from, typval_T const to) FUNC_ATTR_NONNULL_ALL

void	tv_clear (typval_T *const tv)

void	tv_free (typval_T *tv)

void	tv_copy (const typval_T const from, typval_T const to)

void	tv_item_lock (typval_T *const tv, const int deep, const bool lock, const bool check_refcount) FUNC_ATTR_NONNULL_ALL

bool	tv_islocked (const typval_T *const tv) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL

bool	tv_check_lock (const typval_T tv, const char name, size_t name_len) FUNC_ATTR_WARN_UNUSED_RESULT

bool	var_check_lock (VarLockStatus lock, const char *name, size_t name_len)

bool	tv_equal (typval_T const tv1, typval_T const tv2, const bool ic, const bool recursive) FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL

bool	tv_check_str_or_nr (const typval_T *const tv) FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL

bool	tv_check_num (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

bool	tv_check_str (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

varnumber_T	tv_get_number (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

varnumber_T	tv_get_number_chk (const typval_T const tv, bool const ret_error) FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(1)

linenr_T	tv_get_lnum (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

float_T	tv_get_float (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

int	tv_check_for_string (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE

int	tv_check_for_nonempty_string (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE

const char *	tv_get_string_buf_chk (const typval_T const tv, char const buf) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_get_string_chk (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_get_string (const typval_T *const tv) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT

const char *	tv_get_string_buf (const typval_T const tv, char const buf) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT

Variables
bool	tv_in_free_unref_items = false
	Specifies that free_unref_items() function has (not) been entered. More...

const char *const	tv_empty_string = ""

int	i = 0

void argv[0]	v_type = VAR_DICT

argv[0]	v_lock = VAR_UNLOCKED

argv[0] vval	v_dict = dict

argv[1] vval	v_string = (char_u *)xstrdup(key)

argv[2] vval v_dict	dv_refcount

typval_T	rettv

bool	any_needs_free = false

QUEUE *	w

bool	FUNC_ATTR_WARN_UNUSED_RESULT

dictitem_T *const	di = tv_dict_find(d, key, key_len)

typval_T	tv

const bool	res = callback_from_typval(result, &tv)

return	OK

Macro Definition Documentation

◆ CHANGE_LOCK

#define CHANGE_LOCK	(	lock,
		var
	)

Value:

  do { \
    var = ((VarLockStatus[]) { \
      [VAR_UNLOCKED] = (lock ? VAR_LOCKED : VAR_UNLOCKED), \
      [VAR_LOCKED] = (lock ? VAR_LOCKED : VAR_UNLOCKED), \
      [VAR_FIXED] = VAR_FIXED, \
    })[var]; \
  } while (0)

◆ DICT_MAXNEST

#define DICT_MAXNEST 100

◆ FREE_JOIN_TOFREE

#define FREE_JOIN_TOFREE ( join ) xfree((join)->tofree)

◆ FUNC_ERROR [1/2]

#define FUNC_ERROR "E703: Using a Funcref as a Number"

◆ FUNC_ERROR [2/2]

#define FUNC_ERROR "E729: using Funcref as a String"

◆ SL_SIZE

#define SL_SIZE ARRAY_SIZE(sl->sl_items)

◆ SWAP

#define SWAP	(	a,
		b
	)

Value:

  do { \
    tmp = a; \
    a = b; \
    b = tmp; \
  } while (0)

◆ TYPVAL_ENCODE_ALLOW_SPECIALS

#define TYPVAL_ENCODE_ALLOW_SPECIALS false

◆ TYPVAL_ENCODE_CONV_BLOB

#define TYPVAL_ENCODE_CONV_BLOB	(	tv,
		blob,
		len
	)

Value:

  do { \
    tv_blob_unref(tv->vval.v_blob); \
    tv->vval.v_blob = NULL; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_BOOL

#define TYPVAL_ENCODE_CONV_BOOL	(	tv,
		num
	)

Value:

  do { \
    tv->vval.v_bool = kBoolVarFalse; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_DICT_AFTER_KEY

#define TYPVAL_ENCODE_CONV_DICT_AFTER_KEY	(	tv,
		dict
	)

◆ TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS

#define TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS	(	tv,
		dict
	)

◆ TYPVAL_ENCODE_CONV_DICT_END

#define TYPVAL_ENCODE_CONV_DICT_END	(	tv,
		dict
	)

Value:

_nothing_conv_dict_end(tv, (dict_T **)&dict, \

(void *)&TYPVAL_ENCODE_NODICT_VAR)

◆ TYPVAL_ENCODE_CONV_DICT_START

#define TYPVAL_ENCODE_CONV_DICT_START	(	tv,
		dict,
		len
	)

◆ TYPVAL_ENCODE_CONV_EMPTY_DICT

#define TYPVAL_ENCODE_CONV_EMPTY_DICT	(	tv,
		dict
	)

Value:

  do { \
    assert((void *)&dict != (void *)&TYPVAL_ENCODE_NODICT_VAR); \
    _nothing_conv_empty_dict(tv, ((dict_T **)&dict)); \
  } while (0)

◆ TYPVAL_ENCODE_CONV_EMPTY_LIST

#define TYPVAL_ENCODE_CONV_EMPTY_LIST ( tv )

Value:

  do { \
    tv_list_unref(tv->vval.v_list); \
    tv->vval.v_list = NULL; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_EXT_STRING

#define TYPVAL_ENCODE_CONV_EXT_STRING	(	tv,
		buf,
		len,
		type
	)

◆ TYPVAL_ENCODE_CONV_FLOAT

#define TYPVAL_ENCODE_CONV_FLOAT	(	tv,
		flt
	)

Value:

  do { \
    tv->vval.v_float = 0; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS

#define TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS	(	tv,
		len
	)

◆ TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF

#define TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF	(	tv,
		len
	)

◆ TYPVAL_ENCODE_CONV_FUNC_END

#define TYPVAL_ENCODE_CONV_FUNC_END ( tv ) _nothing_conv_func_end(tv, copyID)

◆ TYPVAL_ENCODE_CONV_FUNC_START

#define TYPVAL_ENCODE_CONV_FUNC_START	(	tv,
		fun
	)

Value:

  do { \
    if (_nothing_conv_func_start(tv, fun) != NOTDONE) { \
      return OK; \
    } \
  } while (0)

◆ TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS

#define TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS ( tv )

◆ TYPVAL_ENCODE_CONV_LIST_END

#define TYPVAL_ENCODE_CONV_LIST_END ( tv ) _nothing_conv_list_end(tv)

◆ TYPVAL_ENCODE_CONV_LIST_START

#define TYPVAL_ENCODE_CONV_LIST_START	(	tv,
		len
	)

◆ TYPVAL_ENCODE_CONV_NIL

#define TYPVAL_ENCODE_CONV_NIL ( tv )

Value:

  do { \
    tv->vval.v_special = kSpecialVarNull; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_NUMBER

#define TYPVAL_ENCODE_CONV_NUMBER	(	tv,
		num
	)

Value:

  do { \
    (void)num; \
    tv->vval.v_number = 0; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START

#define TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START	(	tv,
		dict,
		mpsv
	)

Value:

  do { \
    if (_nothing_conv_real_dict_after_start(tv, (dict_T **)&dict, (void *)&TYPVAL_ENCODE_NODICT_VAR, \
                                            &mpsv) != NOTDONE) { \
      goto typval_encode_stop_converting_one_item; \
    } \
  } while (0)

◆ TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START

#define TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START	(	tv,
		mpsv
	)

Value:

  do { \
    if (_nothing_conv_real_list_after_start(tv, &mpsv) != NOTDONE) { \
      goto typval_encode_stop_converting_one_item; \
    } \
  } while (0)

◆ TYPVAL_ENCODE_CONV_RECURSE

#define TYPVAL_ENCODE_CONV_RECURSE	(	val,
		conv_type
	)

◆ TYPVAL_ENCODE_CONV_STR_STRING

#define TYPVAL_ENCODE_CONV_STR_STRING	(	tv,
		buf,
		len
	)

◆ TYPVAL_ENCODE_CONV_STRING

#define TYPVAL_ENCODE_CONV_STRING	(	tv,
		buf,
		len
	)

Value:

  do { \
    xfree(buf); \
    tv->vval.v_string = NULL; \
    tv->v_lock = VAR_UNLOCKED; \
  } while (0)

◆ TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER

#define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER	(	tv,
		num
	)

◆ TYPVAL_ENCODE_FIRST_ARG_NAME

#define TYPVAL_ENCODE_FIRST_ARG_NAME ignored

◆ TYPVAL_ENCODE_FIRST_ARG_TYPE

#define TYPVAL_ENCODE_FIRST_ARG_TYPE const void *const

◆ TYPVAL_ENCODE_NAME

#define TYPVAL_ENCODE_NAME nothing

◆ TYPVAL_ENCODE_SCOPE

#define TYPVAL_ENCODE_SCOPE static

◆ TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK

#define TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK	(	tv,
		dict
	)

◆ TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME

#define TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME

Function Documentation

◆ callback_copy()

void callback_copy	(	Callback *	dest,
		Callback *	src
	)

◆ callback_free()

void callback_free ( Callback * callback )

Unref/free callback.

◆ callback_put()

void callback_put	(	Callback *	cb,
		typval_T *	tv
	)

Copy a callback into a typval_T.

◆ for()

for ( )

◆ if() [1/8]

if ( ! * errp )

◆ if() [2/8]

if ( !tv_is_func(di->di_tv) &&di->di_tv.v_type ! = VAR_STRING )

◆ if() [3/8]

if ( di = = NULL )

◆ if() [4/8]

void if ( len<= 1 )

◆ if() [5/8]

if ( newtv )

◆ if() [6/8]

if ( oldtv )

◆ if() [7/8]

if ( tv_dict_add(d, item) = = FAIL )

◆ if() [8/8]

int int if ( val ! = NULL )

◆ list_log()

list_log	(	l	,
		NULL	,
		NULL	,
		"sort"
	)

◆ qsort()

qsort	(	ptrs	,
		(size_t)	len,
		sizeof(ListSortItem)	,
		item_compare_func
	)

◆ QUEUE_FOREACH()

QUEUE_FOREACH	(	w	,
		&dict->	watchers,
		{ DictWatcher *watcher=tv_dict_watcher_node_data(w);if(!watcher->busy &&tv_dict_watcher_matches(watcher, key)) { rettv=TV_INITIAL_VALUE;watcher->busy=true;callback_call(&watcher->callback, 3, argv, &rettv);watcher->busy=false;tv_clear(&rettv);if(watcher->needs_free) { any_needs_free=true;} } }
	)

◆ tv_blob_alloc()

blob_T* tv_blob_alloc ( void )

Allocate an empty blob.

Caller should take care of the reference count.

Returns: [allocated] new blob.

◆ tv_blob_alloc_ret()

void tv_blob_alloc_ret ( typval_T *const ret_tv )

Allocate an empty blob for a return value.

Also sets reference count.

Parameters

[out] ret_tv Structure where blob is saved.

◆ tv_blob_copy()

void tv_blob_copy	(	typval_T *const	from,
		typval_T *const	to
	)

Copy a blob typval to a different typval.

Parameters

[in]	from	Blob object to copy from.
[out]	to	Blob object to copy to.

◆ tv_blob_equal()

bool tv_blob_equal	(	const blob_T *const	b1,
		const blob_T *const	b2
	)

Check whether two blobs are equal.

Parameters

[in]	b1	First blob.
[in]	b2	Second blob.

Returns: true if blobs are equal, false otherwise.

◆ tv_blob_free()

void tv_blob_free ( blob_T *const b )

Free a blob. Ignores the reference count.

Parameters

[in,out] b Blob to free.

◆ tv_blob_unref()

void tv_blob_unref ( blob_T *const b )

Unreference a blob.

Decrements the reference count and frees blob when it becomes zero.

Parameters

[in,out] b Blob to operate on.

◆ tv_callback_equal()

bool tv_callback_equal	(	const Callback *	cb1,
		const Callback *	cb2
	)

Check whether two callbacks are equal

Parameters

[in]	cb1	First callback to check.
[in]	cb2	Second callback to check.

Returns: True if they are equal, false otherwise.

◆ tv_check_for_nonempty_string()

int tv_check_for_nonempty_string ( const typval_T *const tv )

◆ tv_check_for_string()

int tv_check_for_string ( const typval_T *const tv )

◆ tv_check_lock()

bool tv_check_lock	(	const typval_T *	tv,
		const char *	name,
		size_t	name_len
	)

Return true if typval is locked

Also gives an error message when typval is locked.

Parameters

[in]	tv	Typval.
[in]	name	Variable name, used in the error message.
[in]	name_len	Variable name length. Use TV_TRANSLATE to translate variable name and compute the length. Use TV_CSTRING to compute the length with strlen() without translating.

Both #TV_… values are used for optimization purposes: variable name with its length is needed only in case of error, when no error occurs computing them is a waste of CPU resources. This especially applies to gettext.

Returns: true if variable is locked, false otherwise.

◆ tv_check_num()

bool tv_check_num ( const typval_T *const tv )

Check that given value is a number or can be converted to it

Error messages are compatible with tv_get_number_chk() previously used for the same purpose.

Parameters

[in] tv Value to check.

Returns: true if everything is OK, false otherwise.

◆ tv_check_str()

bool tv_check_str ( const typval_T *const tv )

Check that given value is a VimL String or can be "cast" to it.

Error messages are compatible with tv_get_string_chk() previously used for the same purpose.

Parameters

[in] tv Value to check.

Returns: true if everything is OK, false otherwise.

◆ tv_check_str_or_nr()

bool tv_check_str_or_nr ( const typval_T *const tv )

Check that given value is a number or string

Error messages are compatible with tv_get_number() previously used for the same purpose in buf*() functions. Special values are not accepted (previous behaviour: silently fail to find buffer).

Parameters

[in] tv Value to check.

Returns: true if everything is OK, false otherwise.

◆ tv_clear()

void tv_clear ( typval_T *const tv )

Free memory for a variable value and set the value to NULL or 0

Parameters

[in,out] tv Value to free.

◆ tv_copy()

void tv_copy	(	const typval_T *const	from,
		typval_T *const	to
	)

Copy typval from one location to another

When needed allocates string or increases reference count. Does not make a copy of a container, but copies its reference!

It is OK for from and to to point to the same location; this is used to make a copy later.

Parameters

[in]	from	Location to copy from.
[out]	to	Location to copy to.

◆ tv_dict_add()

int tv_dict_add	(	dict_T *const	d,
		dictitem_T *const	item
	)

Add item to dictionary

Parameters

[out]	d	Dictionary to add to.
[in]	item	Item to add.

Returns: FAIL if key already exists.

◆ tv_dict_add_allocated_str() [1/2]

return tv_dict_add_allocated_str	(	d	,
		key	,
		key_len	,
		s
	)

◆ tv_dict_add_allocated_str() [2/2]

int tv_dict_add_allocated_str	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		char *const	val
	)

Add a string entry to dictionary

Unlike tv_dict_add_str() saves val to the new dictionary item in place of creating a new copy.

Warning: String will be freed even in case addition fails.

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
[in]	val	String to add.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_bool()

int tv_dict_add_bool	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		BoolVarValue	val
	)

Add a boolean entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
[in]	val	BoolVarValue to add.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_dict()

int tv_dict_add_dict	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		dict_T *const	dict
	)

Add a dictionary entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
	dict	Dictionary to add. Will have reference count incremented.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_float()

int tv_dict_add_float	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		const float_T	nr
	)

Add a floating point number entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
[in]	nr	Floating point number to add.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_list()

int tv_dict_add_list	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		list_T *const	list
	)

Add a list entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
	list	List to add. Will have reference count incremented.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_nr()

int tv_dict_add_nr	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		const varnumber_T	nr
	)

Add a number entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
[in]	nr	Number to add.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_str()

int tv_dict_add_str	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		const char *const	val
	)

Add a string entry to dictionary

See also: tv_dict_add_allocated_str

◆ tv_dict_add_str_len()

int int tv_dict_add_str_len	(	dict_T *const	d,
		const char *const	key,
		const size_t	key_len,
		const char *const	val,
		int	len
	)

Add a string entry to dictionary

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.
[in]	val	String to add. NULL adds empty string.
[in]	len	Use this many bytes from `val`, or -1 for whole string.

Returns: OK in case of success, FAIL when key already exists.

◆ tv_dict_add_tv()

int tv_dict_add_tv	(	dict_T *	d,
		const char *	key,
		const size_t	key_len,
		typval_T *	tv
	)

Add a typval entry to dictionary.

Parameters

[out]	d	Dictionary to add entry to.
[in]	key	Key to add.
[in]	key_len	Key length.

Returns: FAIL if out of memory or key already exists.

◆ tv_dict_alloc()

dict_T* tv_dict_alloc ( void )

Allocate an empty dictionary. Caller should take care of the reference count.

Returns: [allocated] new dictionary.

◆ tv_dict_alloc_lock()

dict_T* tv_dict_alloc_lock ( VarLockStatus lock )

◆ tv_dict_alloc_ret()

void tv_dict_alloc_ret ( typval_T *const ret_tv )

Allocate an empty dictionary for a return value

Also sets reference count.

Parameters

[out] ret_tv Structure where dictionary is saved.

◆ tv_dict_clear()

void tv_dict_clear ( dict_T *const d )

Clear all the keys of a Dictionary. "d" remains a valid empty Dictionary.

Parameters

d	The Dictionary to clear

◆ tv_dict_copy()

dict_T* tv_dict_copy	(	const vimconv_T *const	conv,
		dict_T *const	orig,
		const bool	deep,
		const int	copyID
	)

Make a copy of dictionary

Parameters

[in]	conv	If non-NULL, then all internal strings will be converted.
[in]	orig	Original dictionary to copy.
[in]	deep	If false, then shallow copy will be done.
[in]	copyID	See var_item_copy().

Returns: Copied dictionary. May be NULL in case original dictionary is NULL or some failure happens. The refcount of the new dictionary is set to 1.

◆ tv_dict_equal()

bool tv_dict_equal	(	dict_T *const	d1,
		dict_T *const	d2,
		const bool	ic,
		const bool	recursive
	)

Compare two dictionaries

Parameters

[in]	d1	First dictionary.
[in]	d2	Second dictionary.
[in]	ic	True if case is to be ignored.
[in]	recursive	True when used recursively.

◆ tv_dict_extend()

void tv_dict_extend	(	dict_T *const	d1,
		dict_T *const	d2,
		const char *const	action
	)

Extend dictionary with items from another dictionary

Parameters

	d1	Dictionary to extend.
[in]	d2	Dictionary to extend with.
[in]	action	"error", "force", "keep": e, including "error": duplicate key gives an error. f, including "force": duplicate d2 keys override d1. other, including "keep": duplicate d2 keys ignored.

◆ tv_dict_find()

dictitem_T* tv_dict_find	(	const dict_T *const	d,
		const char *const	key,
		const ptrdiff_t	len
	)

Find item in dictionary

Parameters

[in]	d	Dictionary to check.
[in]	key	Dictionary key.
[in]	len	Key length. If negative, then strlen(key) is used.

Returns: found item or NULL if nothing was found.

◆ tv_dict_free()

void tv_dict_free ( dict_T *const d )

Free a dictionary, including all items it contains

Ignores the reference count.

Parameters

d	Dictionary to free.

◆ tv_dict_free_contents()

void tv_dict_free_contents ( dict_T *const d )

Free items contained in a dictionary

Parameters

[in,out] d Dictionary to clear.

◆ tv_dict_free_dict()

void tv_dict_free_dict ( dict_T *const d )

Free a dictionary itself, ignoring items it contains

Ignores the reference count.

Parameters

[in,out] d Dictionary to free.

◆ tv_dict_get_callback()

bool tv_dict_get_callback	(	dict_T *const	d,
		const char *const	key,
		const ptrdiff_t	key_len,
		Callback *const	result
	)

Get a function from a dictionary

Parameters

[in]	d	Dictionary to get callback from.
[in]	key	Dictionary key.
[in]	key_len	Key length, may be -1 to use strlen().
[out]	result	The address where a pointer to the wanted callback will be left.

Returns: true/false on success/failure.

◆ tv_dict_get_number()

varnumber_T tv_dict_get_number	(	const dict_T *const	d,
		const char *const	key
	)

Get a number item from a dictionary

Returns 0 if the entry does not exist.

Parameters

[in]	d	Dictionary to get item from.
[in]	key	Key to find in dictionary.

Returns: Dictionary item.

◆ tv_dict_get_string()

char* tv_dict_get_string	(	const dict_T *const	d,
		const char *const	key,
		const bool	save
	)

Get a string item from a dictionary

Parameters

[in]	d	Dictionary to get item from.
[in]	key	Dictionary key.
[in]	save	If true, returned string will be placed in the allocated memory.

Returns: NULL if key does not exist, empty string in case of type error, string item value otherwise. If returned value is not NULL, it may be allocated depending on save argument.

◆ tv_dict_get_string_buf()

const char* tv_dict_get_string_buf	(	const dict_T *const	d,
		const char *const	key,
		char *const	numbuf
	)

Get a string item from a dictionary

Parameters

[in]	d	Dictionary to get item from.
[in]	key	Dictionary key.
[in]	numbuf	Buffer for non-string items converted to strings, at least of NUMBUFLEN length.

Returns: NULL if key does not exist, empty string in case of type error, string item value otherwise.

◆ tv_dict_get_string_buf_chk()

const char* tv_dict_get_string_buf_chk	(	const dict_T *const	d,
		const char *const	key,
		const ptrdiff_t	key_len,
		char *const	numbuf,
		const char *const	def
	)

Get a string item from a dictionary

Parameters

[in]	d	Dictionary to get item from.
[in]	key	Dictionary key.
[in]	key_len	Key length.
[in]	numbuf	Buffer for non-string items converted to strings, at least of NUMBUFLEN length.
[in]	def	Default return when key does not exist.

Returns: def when key does not exist, NULL in case of type error, string item value in case of success.

◆ tv_dict_get_tv()

int tv_dict_get_tv	(	dict_T *	d,
		const char *const	key,
		typval_T *	rettv
	)

Get a typval item from a dictionary and copy it into "rettv".

Parameters

[in]	d	Dictionary to check.
[in]	key	Dictionary key.
[in]	rettv	Return value.

Returns: OK in case of success or FAIL if nothing was found.

◆ tv_dict_item_alloc()

dictitem_T* tv_dict_item_alloc ( const char *const key )

Allocate a dictionary item

Note: that the type and value of the item (->di_tv) still needs to be initialized.

Parameters

[in] key Key, is copied to the new item.

Returns: [allocated] new dictionary item.

◆ tv_dict_item_alloc_len()

dictitem_T* tv_dict_item_alloc_len	(	const char *const	key,
		const size_t	key_len
	)

Allocate a dictionary item

Note: that the type and value of the item (->di_tv) still needs to be initialized.

Parameters

[in]	key	Key, is copied to the new item.
[in]	key_len	Key length.

Returns: [allocated] new dictionary item.

◆ tv_dict_item_copy()

dictitem_T* tv_dict_item_copy ( dictitem_T *const di )

Make a copy of a dictionary item

Parameters

[in] di Item to copy.

Returns: [allocated] new dictionary item.

◆ tv_dict_item_free()

void tv_dict_item_free ( dictitem_T *const item )

Free a dictionary item, also clearing the value

Parameters

item	Item to free.

◆ tv_dict_item_remove()

void tv_dict_item_remove	(	dict_T *const	dict,
		dictitem_T *const	item
	)

Remove item from dictionary and free it

Parameters

dict	Dictionary to remove item from.
item	Item to remove.

◆ tv_dict_set_keys_readonly()

void tv_dict_set_keys_readonly ( dict_T *const dict )

Set all existing keys in "dict" as read-only.

This does not protect against adding new keys to the Dictionary.

Parameters

dict	The dict whose keys should be frozen.

◆ tv_dict_to_env()

char** tv_dict_to_env ( dict_T * denv )

Converts a dict to an environment

◆ tv_dict_unref() [1/2]

tv_dict_unref ( dict )

◆ tv_dict_unref() [2/2]

void tv_dict_unref ( dict_T *const d )

Unreference a dictionary

Decrements the reference count and frees dictionary when it becomes zero.

Parameters

[in] d Dictionary to operate on.

◆ tv_dict_watcher_add()

void tv_dict_watcher_add	(	dict_T *const	dict,
		const char *const	key_pattern,
		const size_t	key_pattern_len,
		Callback	callback
	)

Add watcher to a dictionary

Parameters

[in]	dict	Dictionary to add watcher to.
[in]	key_pattern	Pattern to watch for.
[in]	key_pattern_len	Key pattern length.
	callback	Function to be called on events.

◆ tv_dict_watcher_notify()

void tv_dict_watcher_notify	(	dict_T *const	dict,
		const char *const	key,
		typval_T *const	newtv,
		typval_T *const	oldtv
	)

Send a change notification to all dictionary watchers that match given key

Parameters

[in]	dict	Dictionary which was modified.
[in]	key	Key which was modified.
[in]	newtv	New key value.
[in]	oldtv	Old key value.

◆ tv_dict_watcher_remove()

bool tv_dict_watcher_remove	(	dict_T *const	dict,
		const char *const	key_pattern,
		const size_t	key_pattern_len,
		Callback	callback
	)

Remove watcher from a dictionary

Parameters

	dict	Dictionary to remove watcher from.
[in]	key_pattern	Pattern to remove watcher for.
[in]	key_pattern_len	Pattern length.
	callback	Callback to remove watcher for.

Returns: True on success, false if relevant watcher was not found.

◆ tv_equal()

bool tv_equal	(	typval_T *const	tv1,
		typval_T *const	tv2,
		const bool	ic,
		const bool	recursive
	)

Compare two VimL values

Like "==", but strings and numbers are different, as well as floats and numbers.

Warning: Too nested structures may be considered equal even if they are not.

Parameters

[in]	tv1	First value to compare.
[in]	tv2	Second value to compare.
[in]	ic	True if case is to be ignored.
[in]	recursive	True when used recursively.

Returns: true if values are equal.

◆ tv_free()

void tv_free ( typval_T * tv )

Free allocated VimL object and value stored inside

Parameters

tv	Object to free.

◆ tv_get_float()

float_T tv_get_float ( const typval_T *const tv )

Get the floating-point value of a VimL object

Raises an error if object is not number or floating-point.

Parameters

[in] tv Object to get value of.

Returns: Floating-point value of the variable or zero.

◆ tv_get_lnum()

linenr_T tv_get_lnum ( const typval_T *const tv )

Get the line number from VimL object

Parameters

[in] tv Object to get value from. Is expected to be a number or a special string like ".", "$", … (works with current buffer only).

Returns: Line number or -1 or 0.

◆ tv_get_number()

varnumber_T tv_get_number ( const typval_T *const tv )

Get the number value of a VimL object

Note: Use tv_get_number_chk() if you need to determine whether there was an error.

Parameters

[in] tv Object to get value from.

Returns: Number value: vim_str2nr() output for VAR_STRING objects, value for VAR_NUMBER objects, -1 for other types.

◆ tv_get_number_chk()

varnumber_T tv_get_number_chk	(	const typval_T *const	tv,
		bool *const	ret_error
	)

Get the number value of a VimL object

Parameters

[in]	tv	Object to get value from.
[out]	ret_error	If type error occurred then `true` will be written to this location. Otherwise it is not touched.

Note: Needs to be initialized to false to be useful.

Returns: Number value: vim_str2nr() output for VAR_STRING objects, value for VAR_NUMBER objects, -1 (ret_error == NULL) or 0 (otherwise) for other types.

◆ tv_get_string()

const char* tv_get_string ( const typval_T *const tv )

Get the string value of a "stringish" VimL object.

Warning: For number and special values it uses a single, static buffer. It may be used only once, next call to tv_get_string may reuse it. Use tv_get_string_buf() if you need to use tv_get_string() output after calling it again.

Note: tv_get_string_chk() and tv_get_string_buf_chk() are similar, but return NULL on error.

Parameters

[in] tv Object to get value of.

Returns: Object value if it is VAR_STRING object, number converted to a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or empty string.

◆ tv_get_string_buf()

const char* tv_get_string_buf	(	const typval_T *const	tv,
		char *const	buf
	)

Get the string value of a "stringish" VimL object.

Note: tv_get_string_chk() and tv_get_string_buf_chk() are similar, but return NULL on error.

Parameters

[in]	tv	Object to get value of.
	buf	Buffer used to hold numbers and special variables converted to string. When function encounters one of these stringified value will be written to buf and buf will be returned.

Buffer must have NUMBUFLEN size.

Returns: Object value if it is VAR_STRING object, number converted to a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or empty string.

◆ tv_get_string_buf_chk()

const char* tv_get_string_buf_chk	(	const typval_T *const	tv,
		char *const	buf
	)

Get the string value of a "stringish" VimL object.

Parameters

[in]	tv	Object to get value of.
	buf	Buffer used to hold numbers and special variables converted to string. When function encounters one of these stringified value will be written to buf and buf will be returned.

Buffer must have NUMBUFLEN size.

Returns: Object value if it is VAR_STRING object, number converted to a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or NULL.

◆ tv_get_string_chk()

const char* tv_get_string_chk ( const typval_T *const tv )

Get the string value of a "stringish" VimL object.

Warning: For number and special values it uses a single, static buffer. It may be used only once, next call to tv_get_string may reuse it. Use tv_get_string_buf() if you need to use tv_get_string() output after calling it again.

Parameters

[in] tv Object to get value of.

Returns: Object value if it is VAR_STRING object, number converted to a string for VAR_NUMBER, v: variable name for VAR_SPECIAL or NULL.

◆ tv_islocked()

bool tv_islocked ( const typval_T *const tv )

Check whether VimL value is locked itself or refers to a locked container

Warning: Fixed container is not the same as locked.

Parameters

[in] tv Value to check.

Returns: True if value is locked, false otherwise.

◆ tv_item_lock()

void tv_item_lock	(	typval_T *const	tv,
		const int	deep,
		const bool	lock,
		const bool	check_refcount
	)

Lock or unlock an item

Parameters

[out]	tv	Item to (un)lock.
[in]	deep	Levels to (un)lock, -1 to (un)lock everything.
[in]	lock	True if it is needed to lock an item, false to unlock.
[in]	check_refcount	If true, do not lock a list or dict with a reference count larger than 1.

◆ tv_list_alloc()

list_T* tv_list_alloc ( const ptrdiff_t len )

Allocate an empty list

Caller should take care of the reference count.

Parameters

[in] len Expected number of items to be populated before list becomes accessible from VimL. It is still valid to underpopulate a list, value only controls how many elements will be allocated in advance. Currently does nothing.

See also: ListLenSpecials.

Returns: [allocated] new list.

◆ tv_list_alloc_ret()

list_T* tv_list_alloc_ret	(	typval_T *const	ret_tv,
		const ptrdiff_t	len
	)

Allocate an empty list for a return value

Also sets reference count.

Parameters

[out]	ret_tv	Structure where list is saved.
[in]	len	Expected number of items to be populated before list becomes accessible from VimL. It is still valid to underpopulate a list, value only controls how many elements will be allocated in advance.

See also: ListLenSpecials.

Returns: [allocated] pointer to the created list.

◆ tv_list_drop_items()

void tv_list_drop_items	(	list_T *const	l,
		listitem_T *const	item,
		listitem_T *const	item2
	)

Remove items "item" to "item2" from list "l"

Warning: Does not free the listitem or the value!

Parameters

[out]	l	List to remove from.
[in]	item	First item to remove.
[in]	item2	Last item to remove.

◆ tv_list_equal()

bool tv_list_equal	(	list_T *const	l1,
		list_T *const	l2,
		const bool	ic,
		const bool	recursive
	)

Check whether two lists are equal

Parameters

[in]	l1	First list to compare.
[in]	l2	Second list to compare.
[in]	ic	True if case is to be ignored.
[in]	recursive	True when used recursively.

Returns: True if lists are equal, false otherwise.

◆ tv_list_find()

listitem_T* tv_list_find	(	list_T *const	l,
		int	n
	)

Locate item with a given index in a list and return it

Parameters

[in]	l	List to index.
[in]	n	Index. Negative index is counted from the end, -1 is the last item.

Returns: Item at the given index or NULL if n is out of range.

◆ tv_list_find_nr()

varnumber_T tv_list_find_nr	(	list_T *const	l,
		const int	n,
		bool *const	ret_error
	)

Get list item l[n] as a number

Parameters

[in]	l	List to index.
[in]	n	Index in a list.
[out]	ret_error	Location where 1 will be saved if index was not found. May be NULL. If everything is OK, `*ret_error` is not touched.

Returns: Integer value at the given index or -1.

◆ tv_list_find_str()

const char* tv_list_find_str	(	list_T *const	l,
		const int	n
	)

Get list item l[n] as a string

Parameters

[in]	l	List to index.
[in]	n	Index in a list.

Returns: List item string value or NULL in case of error.

◆ tv_list_free()

void tv_list_free ( list_T *const l )

Free a list, including all items it points to

Ignores the reference count. Does not do anything if tv_in_free_unref_items is true.

Parameters

[in,out] l List to free.

◆ tv_list_free_contents()

void tv_list_free_contents ( list_T *const l )

Free items contained in a list

Parameters

[in,out] l List to clear.

◆ tv_list_free_list()

void tv_list_free_list ( list_T *const l )

Free a list itself, ignoring items it contains

Ignores the reference count.

Parameters

[in,out] l List to free.

◆ tv_list_idx_of_item()

long tv_list_idx_of_item	(	const list_T *const	l,
		const listitem_T *const	item
	)

Locate item in a list and return its index

Parameters

[in]	l	List to search.
[in]	item	Item to search for.

Returns: Index of an item or -1 if item is not in the list.

◆ tv_list_init_static()

void tv_list_init_static ( list_T *const l )

Initialize static list with undefined number of elements

Parameters

[out] l List to initialize.

◆ tv_list_init_static10()

void tv_list_init_static10 ( staticList10_T *const sl )

Initialize a static list with 10 items

Parameters

[out] sl Static list to initialize.

◆ tv_list_insert()

void tv_list_insert	(	list_T *const	l,
		listitem_T *const	ni,
		listitem_T *const	item
	)

Insert list item

Parameters

[out]	l	List to insert to.
[in,out]	ni	Item to insert.
[in]	item	Item to insert before. If NULL, inserts at the end of the list.

◆ tv_list_item_remove()

listitem_T* tv_list_item_remove	(	list_T *const	l,
		listitem_T *const	item
	)

Remove a list item from a List and free it

Also clears the value.

Parameters

[out]	l	List to remove item from.
[in,out]	item	Item to remove.

Returns: Pointer to the list item just after removed one, NULL if removed item was the last one.

◆ tv_list_item_sort()

void tv_list_item_sort	(	list_T *const	l,
		ListSortItem *const	ptrs,
		const ListSorter	item_compare_func,
		bool *	errp
	)

Sort list using libc qsort

Parameters

[in,out]	l	List to sort, will be sorted in-place.
	ptrs	Preallocated array of items to sort, must have at least tv_list_len(l) entries. Should not be initialized.
[in]	item_compare_func	Function used to compare list items.
	errp	Location where information about whether error occurred is saved by item_compare_func. If boolean there appears to be true list will not be modified. Must be initialized to false by the caller.

◆ TV_LIST_ITER()

TV_LIST_ITER	(	l	,
		li	,
		{ ptrs[i].item=li;ptrs[i].idx=i;i++;}
	)

◆ tv_list_join()

int tv_list_join	(	garray_T *const	gap,
		list_T *const	l,
		const char *const	sep
	)

Join list into a string using given separator

Parameters

[out]	gap	Garray where result will be saved.
[in]	l	Joined list.
[in]	sep	Separator.

Returns: OK in case of success, FAIL otherwise.

◆ tv_list_move_items()

void tv_list_move_items	(	list_T *const	l,
		listitem_T *const	item,
		listitem_T *const	item2,
		list_T *const	tgt_l,
		const int	cnt
	)

Move items "item" to "item2" from list "l" to the end of the list "tgt_l"

Parameters

[out]	l	List to move from.
[in]	item	First item to move.
[in]	item2	Last item to move.
[out]	tgt_l	List to move to.
[in]	cnt	Number of items moved.

◆ tv_list_remove_items()

void tv_list_remove_items	(	list_T *const	l,
		listitem_T *const	item,
		listitem_T *const	item2
	)

Like tv_list_drop_items, but also frees all removed items.

◆ tv_list_reverse()

void tv_list_reverse ( list_T *const l )

Reverse list in-place

Parameters

[in,out] l List to reverse.

◆ tv_list_unref()

void tv_list_unref ( list_T *const l )

Unreference a list

Decrements the reference count and frees when it becomes zero or less.

Parameters

[in,out] l List to unreference.

◆ tv_list_watch_add()

void tv_list_watch_add	(	list_T *const	l,
		listwatch_T *const	lw
	)

Add a watcher to a list

Parameters

[out]	l	List to add watcher to.
[in]	lw	Watcher to add.

◆ tv_list_watch_fix()

void tv_list_watch_fix	(	list_T *const	l,
		const listitem_T *const	item
	)

Advance watchers to the next item

Used just before removing an item from a list.

Parameters

[out]	l	List from which item is removed.
[in]	item	List item being removed.

◆ tv_list_watch_remove()

void tv_list_watch_remove	(	list_T *const	l,
		listwatch_T *const	lwrem
	)

Remove a watcher from a list

Does not give a warning if watcher was not found.

Parameters

[out]	l	List to remove watcher from.
[in]	lwrem	Watcher to remove.

◆ var_check_lock()

bool var_check_lock	(	VarLockStatus	lock,
		const char *	name,
		size_t	name_len
	)

Returns: true if variable "name" is locked (immutable)

Variable Documentation

◆ any_needs_free

bool any_needs_free = false

◆ di

tv_copy & di = tv_dict_find(d, key, key_len)

◆ dv_refcount

dict dv_refcount

◆ FUNC_ATTR_WARN_UNUSED_RESULT

bool FUNC_ATTR_WARN_UNUSED_RESULT

Initial value:

{

result->type = kCallbackNone

◆ i

int i = 0

◆ OK

return OK

◆ res

return res = callback_from_typval(result, &tv)

◆ rettv

tv_clear & rettv

◆ tv

tv_clear & tv

◆ tv_empty_string

const char* const tv_empty_string = ""

Empty string

Needed for hack which allows not allocating empty string and still not crashing when freeing it.

◆ tv_in_free_unref_items

bool tv_in_free_unref_items = false

Specifies that free_unref_items() function has (not) been entered.

◆ v_dict

argv [2] vval v_dict = dict

◆ v_lock

argv [2] v_lock = VAR_UNLOCKED

◆ v_string

item di_tv vval v_string = (char_u *)xstrdup(key)

◆ v_type

var2 v_type = VAR_DICT

◆ w

QUEUE* w

Macros

Functions

Variables

Macro Definition Documentation

◆ CHANGE_LOCK

◆ DICT_MAXNEST

◆ FREE_JOIN_TOFREE

◆ FUNC_ERROR [1/2]

◆ FUNC_ERROR [2/2]

◆ SL_SIZE

◆ SWAP

◆ TYPVAL_ENCODE_ALLOW_SPECIALS

◆ TYPVAL_ENCODE_CONV_BLOB

◆ TYPVAL_ENCODE_CONV_BOOL

◆ TYPVAL_ENCODE_CONV_DICT_AFTER_KEY

◆ TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS

◆ TYPVAL_ENCODE_CONV_DICT_END

◆ TYPVAL_ENCODE_CONV_DICT_START

◆ TYPVAL_ENCODE_CONV_EMPTY_DICT

◆ TYPVAL_ENCODE_CONV_EMPTY_LIST

◆ TYPVAL_ENCODE_CONV_EXT_STRING

◆ TYPVAL_ENCODE_CONV_FLOAT

◆ TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS

◆ TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF

◆ TYPVAL_ENCODE_CONV_FUNC_END

◆ TYPVAL_ENCODE_CONV_FUNC_START

◆ TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS

◆ TYPVAL_ENCODE_CONV_LIST_END

◆ TYPVAL_ENCODE_CONV_LIST_START

◆ TYPVAL_ENCODE_CONV_NIL

◆ TYPVAL_ENCODE_CONV_NUMBER

◆ TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START

◆ TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START

◆ TYPVAL_ENCODE_CONV_RECURSE

◆ TYPVAL_ENCODE_CONV_STR_STRING

◆ TYPVAL_ENCODE_CONV_STRING

◆ TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER

◆ TYPVAL_ENCODE_FIRST_ARG_NAME

◆ TYPVAL_ENCODE_FIRST_ARG_TYPE

◆ TYPVAL_ENCODE_NAME

◆ TYPVAL_ENCODE_SCOPE

◆ TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK

◆ TYPVAL_ENCODE_TRANSLATE_OBJECT_NAME

Function Documentation

◆ callback_copy()

◆ callback_free()

◆ callback_put()

◆ for()

◆ if() [1/8]

◆ if() [2/8]

◆ if() [3/8]

◆ if() [4/8]

◆ if() [5/8]

◆ if() [6/8]

◆ if() [7/8]

◆ if() [8/8]

◆ list_log()

◆ qsort()

◆ QUEUE_FOREACH()

◆ tv_blob_alloc()

◆ tv_blob_alloc_ret()

◆ tv_blob_copy()

◆ tv_blob_equal()

◆ tv_blob_free()

◆ tv_blob_unref()

◆ tv_callback_equal()

◆ tv_check_for_nonempty_string()

◆ tv_check_for_string()

◆ tv_check_lock()

◆ tv_check_num()

◆ tv_check_str()

◆ tv_check_str_or_nr()

◆ tv_clear()

◆ tv_copy()

◆ tv_dict_add()

◆ tv_dict_add_allocated_str() [1/2]

◆ tv_dict_add_allocated_str() [2/2]

◆ tv_dict_add_bool()

◆ tv_dict_add_dict()

◆ tv_dict_add_float()