eval: Split eval.c into smaller files

47 files changed, 2752 insertions, 2316 deletions

diff --git a/src/clint.py b/src/clint.py
index ce31822ada..61c53d128e 100755
--- a/src/clint.py
+++ b/src/clint.py
@@ -2268,11 +2268,14 @@ def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
                 # //!<  Header comment
                 # or they begin with multiple slashes followed by a space:
                 # //////// Header comment
+                # or they are Vim {{{ fold markers
                 match = (Search(r'[=/-]{4,}\s*$', line[commentend:]) or
                          Search(r'^/$', line[commentend:]) or
                          Search(r'^!< ', line[commentend:]) or
                          Search(r'^/< ', line[commentend:]) or
-                         Search(r'^/+ ', line[commentend:]))
+                         Search(r'^/+ ', line[commentend:]) or
+                         Search(r'^(?:\{{3}|\}{3})\d*(?: |$)',
+                                line[commentend:]))
                 if not match:
                     error(filename, linenum, 'whitespace/comments', 4,
                           'Should have a space between // and comment')
@@ -3575,7 +3578,7 @@ def main():
 if __name__ == '__main__':
     main()
 
-# vim: ts=4 sts=4 sw=4
+# vim: ts=4 sts=4 sw=4 foldmarker=▶,▲
 
 # Ignore "too complex" warnings when using pymode.
 # pylama:ignore=C901
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index 7efa086af2..ff45cad8f5 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -14,6 +14,7 @@
 #include "nvim/window.h"
 #include "nvim/memory.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/map_defs.h"
 #include "nvim/map.h"
 #include "nvim/option.h"
@@ -87,7 +88,7 @@ bool try_end(Error *err)
 /// @param[out] err Details of an error that may have occurred
 Object dict_get_value(dict_T *dict, String key, Error *err)
 {
-  hashitem_T *hi = hash_find(&dict->dv_hashtab, (uint8_t *) key.data);
+  hashitem_T *hi = hash_find(&dict->dv_hashtab, (char_u *)key.data);
 
   if (HASHITEM_EMPTY(hi)) {
     api_set_error(err, Validation, _("Key not found"));
@@ -177,13 +178,13 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
       if (retval) {
         rv = vim_to_object(&di->di_tv);
       }
-      clear_tv(&di->di_tv);
+      tv_clear(&di->di_tv);
     }
 
     // Update the value
     copy_tv(&tv, &di->di_tv);
     // Clear the temporary variable
-    clear_tv(&tv);
+    tv_clear(&tv);
   }
 
   return rv;
@@ -682,20 +683,20 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
       break;
 
     case kObjectTypeArray: {
-      list_T *list = list_alloc();
+      list_T *const list = tv_list_alloc();
 
       for (uint32_t i = 0; i < obj.data.array.size; i++) {
         Object item = obj.data.array.items[i];
-        listitem_T *li = listitem_alloc();
+        listitem_T *li = tv_list_item_alloc();
 
         if (!object_to_vim(item, &li->li_tv, err)) {
           // cleanup
-          listitem_free(li);
-          list_free(list);
+          tv_list_item_free(li);
+          tv_list_free(list);
           return false;
         }
 
-        list_append(list, li);
+        tv_list_append(list, li);
       }
       list->lv_refcount++;
 
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 413456c615..59c0200395 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -22,6 +22,7 @@
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/option.h"
 #include "nvim/syntax.h"
 #include "nvim/getchar.h"
@@ -237,11 +238,11 @@ Object nvim_call_function(String fname, Array args, Error *err)
   if (!try_end(err)) {
     rv = vim_to_object(&rettv);
   }
-  clear_tv(&rettv);
+  tv_clear(&rettv);
 
 free_vim_args:
   while (i > 0) {
-    clear_tv(&vim_args[--i]);
+    tv_clear(&vim_args[--i]);
   }
 
   return rv;
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 4a07884f98..f7333fead4 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -1472,7 +1472,7 @@ static inline void buf_init_changedtick(buf_T *const buf)
 {
   STATIC_ASSERT(sizeof("changedtick") <= sizeof(buf->changedtick_di.di_key),
                 "buf->changedtick_di cannot hold large enough keys");
-  buf->changedtick_di = (dictitem16_T) {
+  buf->changedtick_di = (ChangedtickDictItem) {
     .di_flags = DI_FLAGS_RO|DI_FLAGS_FIX,  // Must not include DI_FLAGS_ALLOC.
     .di_tv = (typval_T) {
       .v_type = VAR_NUMBER,
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 9d350c763e..20a2b931bd 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -21,8 +21,6 @@ typedef struct {
 #include "nvim/pos.h"
 // for the number window-local and buffer-local options
 #include "nvim/option_defs.h"
-// for optional iconv support
-#include "nvim/iconv.h"
 // for jump list and tag stack sizes in a buffer and mark types
 #include "nvim/mark_defs.h"
 // for u_header_T; needs buf_T.
@@ -30,7 +28,9 @@ typedef struct {
 // for hashtab_T
 #include "nvim/hashtab.h"
 // for dict_T
-#include "nvim/eval_defs.h"
+#include "nvim/eval/typval.h"
+// for proftime_T
+#include "nvim/profile.h"
 // for String
 #include "nvim/api/private/defs.h"
 // for Map(K, V)
@@ -319,25 +319,6 @@ typedef struct {
 } tasave_T;
 
 /*
- * Used for conversion of terminal I/O and script files.
- */
-typedef struct {
-  int vc_type;                  /* zero or one of the CONV_ values */
-  int vc_factor;                /* max. expansion factor */
-# ifdef USE_ICONV
-  iconv_t vc_fd;                /* for CONV_ICONV */
-# endif
-  bool vc_fail;                 /* fail for invalid char, don't use '?' */
-} vimconv_T;
-
-#define CONV_NONE               0
-#define CONV_TO_UTF8            1
-#define CONV_9_TO_UTF8          2
-#define CONV_TO_LATIN1          3
-#define CONV_TO_LATIN9          4
-#define CONV_ICONV              5
-
-/*
  * Structure used for mappings and abbreviations.
  */
 typedef struct mapblock mapblock_T;
@@ -447,6 +428,10 @@ typedef struct {
   char_u *b_syn_isk;            // iskeyword option
 } synblock_T;
 
+/// Type used for changedtick_di member in buf_T
+///
+/// Primary exists so that literals of relevant type can be made.
+typedef TV_DICTITEM_STRUCT(sizeof("changedtick")) ChangedtickDictItem;
 
 #define BUF_HAS_QF_ENTRY 1
 #define BUF_HAS_LL_ENTRY 2
@@ -491,7 +476,7 @@ struct file_buffer {
                                 // file has been changed and not written out.
 /// Change identifier incremented for each change, including undo
 #define b_changedtick changedtick_di.di_tv.vval.v_number
-  dictitem16_T changedtick_di;  // b:changedtick dictionary item.
+  ChangedtickDictItem changedtick_di;  // b:changedtick dictionary item.
 
   bool b_saving;                /* Set to true if we are in the middle of
                                    saving the buffer. */
@@ -735,8 +720,8 @@ struct file_buffer {
   int b_bad_char;               /* "++bad=" argument when edit started or 0 */
   int b_start_bomb;             /* 'bomb' when it was read */
 
-  dictitem_T b_bufvar;          /* variable for "b:" Dictionary */
-  dict_T      *b_vars;          /* internal variables, local to buffer */
+  ScopeDictDictItem b_bufvar;  ///< Variable for "b:" Dictionary.
+  dict_T *b_vars;  ///< b: scope dictionary.
 
   /* When a buffer is created, it starts without a swap file.  b_may_swap is
    * then set to indicate that a swap file may be opened later.  It is reset
@@ -824,9 +809,9 @@ struct tabpage_S {
   buf_T           *(tp_diffbuf[DB_COUNT]);
   int tp_diff_invalid;              ///< list of diffs is outdated
   frame_T         *(tp_snapshot[SNAP_COUNT]);    ///< window layout snapshots
-  dictitem_T tp_winvar;             ///< variable for "t:" Dictionary
-  dict_T          *tp_vars;         ///< internal variables, local to tab page
-  char_u          *tp_localdir;     ///< Absolute path of local CWD or NULL
+  ScopeDictDictItem tp_winvar;      ///< Variable for "t:" Dictionary.
+  dict_T          *tp_vars;         ///< Internal variables, local to tab page.
+  char_u          *tp_localdir;     ///< Absolute path of local cwd or NULL.
 };
 
 /*
@@ -1118,8 +1103,8 @@ struct window_S {
 
   long w_scbind_pos;
 
-  dictitem_T w_winvar;          /* variable for "w:" Dictionary */
-  dict_T      *w_vars;          /* internal variables, local to window */
+  ScopeDictDictItem w_winvar;  ///< Variable for "w:" dictionary.
+  dict_T *w_vars;  ///< Dictionary with w: variables.
 
   int w_farsi;                  /* for the window dependent Farsi functions */
 
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index efe32b915f..cb6a9fa43c 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -41,8 +41,10 @@ static bool chartab_initialized = false;
     (buf)->b_chartab[(unsigned)(c) >> 6] |= (1ull << ((c) & 0x3f))
 #define RESET_CHARTAB(buf, c) \
     (buf)->b_chartab[(unsigned)(c) >> 6] &= ~(1ull << ((c) & 0x3f))
+#define GET_CHARTAB_TAB(chartab, c) \
+    ((chartab)[(unsigned)(c) >> 6] & (1ull << ((c) & 0x3f)))
 #define GET_CHARTAB(buf, c) \
-    ((buf)->b_chartab[(unsigned)(c) >> 6] & (1ull << ((c) & 0x3f)))
+    GET_CHARTAB_TAB((buf)->b_chartab, c)
 
 // Table used below, see init_chartab() for an explanation
 static char_u g_chartab[256];
@@ -634,7 +636,7 @@ int char2cells(int c)
 /// @param p
 ///
 /// @return number of display cells.
-int ptr2cells(char_u *p)
+int ptr2cells(const char_u *p)
 {
   // For UTF-8 we need to look at more bytes if the first byte is >= 0x80.
   if (*p >= 0x80) {
@@ -776,6 +778,21 @@ bool vim_iswordc(int c)
   return vim_iswordc_buf(c, curbuf);
 }
 
+/// Check that "c" is a keyword character
+/// Letters and characters from 'iskeyword' option for given buffer.
+/// For multi-byte characters mb_get_class() is used (builtin rules).
+///
+/// @param[in]  c  Character to check.
+/// @param[in]  chartab  Buffer chartab.
+bool vim_iswordc_tab(const int c, const uint64_t *const chartab)
+  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
+{
+  if (c >= 0x100) {
+    return utf_class(c) >= 2;
+  }
+  return c > 0 && c < 0x100 && GET_CHARTAB_TAB(chartab, c) != 0;
+}
+
 /// Check that "c" is a keyword character:
 /// Letters and characters from 'iskeyword' option for given buffer.
 /// For multi-byte characters mb_get_class() is used (builtin rules).
@@ -785,10 +802,7 @@ bool vim_iswordc(int c)
 bool vim_iswordc_buf(int c, buf_T *buf)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(2)
 {
-  if (c >= 0x100) {
-    return utf_class(c) >= 2;
-  }
-  return c > 0 && c < 0x100 && GET_CHARTAB(buf, c) != 0;
+  return vim_iswordc_tab(c, buf->b_chartab);
 }
 
 /// Just like vim_iswordc() but uses a pointer to the (multi-byte) character.
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index 82f1bf0a16..45abd314fc 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -12,6 +12,7 @@
 #include "nvim/state.h"
 #include "nvim/vim.h"
 #include "nvim/ascii.h"
+#include "nvim/mark.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "cursor.c.generated.h"
@@ -227,9 +228,10 @@ static int coladvance2(
     }
   }
 
-  /* prevent from moving onto a trail byte */
-  if (has_mbyte)
-    mb_adjustpos(curbuf, pos);
+  // Prevent from moving onto a trail byte.
+  if (has_mbyte) {
+    mark_mb_adjustpos(curbuf, pos);
+  }
 
   if (col < wcol)
     return FAIL;
@@ -361,9 +363,10 @@ void check_cursor_col_win(win_T *win)
       win->w_cursor.col = len;
     } else {
       win->w_cursor.col = len - 1;
-      /* Move the cursor to the head byte. */
-      if (has_mbyte)
-        mb_adjustpos(win->w_buffer, &win->w_cursor);
+      // Move the cursor to the head byte.
+      if (has_mbyte) {
+        mark_mb_adjustpos(win->w_buffer, &win->w_cursor);
+      }
     }
   } else if (win->w_cursor.col < 0) {
     win->w_cursor.col = 0;
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 5544f0b163..77d5b2c816 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -15,6 +15,7 @@
 #include "nvim/cursor.h"
 #include "nvim/digraph.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
 #include "nvim/farsi.h"
@@ -3461,8 +3462,8 @@ expand_by_function (
       matchdict = rettv.vval.v_dict;
       break;
     default:
-      /* TODO: Give error message? */
-      clear_tv(&rettv);
+      // TODO(brammool): Give error message?
+      tv_clear(&rettv);
       break;
     }
   }
@@ -3484,10 +3485,12 @@ expand_by_function (
     ins_compl_add_dict(matchdict);
 
 theend:
-  if (matchdict != NULL)
+  if (matchdict != NULL) {
     dict_unref(matchdict);
-  if (matchlist != NULL)
-    list_unref(matchlist);
+  }
+  if (matchlist != NULL) {
+    tv_list_unref(matchlist);
+  }
 }
 
 /*
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 927a1dcb0e..03d6eef9e3 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -94,7 +94,11 @@
 #include "nvim/lib/kvec.h"
 #include "nvim/lib/khash.h"
 #include "nvim/lib/queue.h"
-#include "nvim/eval/typval_encode.h"
+#include "nvim/eval/typval.h"
+#include "nvim/eval/executor.h"
+#include "nvim/eval/gc.h"
+
+// TODO(ZyX-I): Remove DICT_MAXNEST, make users be non-recursive instead
 
 #define DICT_MAXNEST 100        /* maximum nesting of lists and dicts */
 
@@ -150,7 +154,6 @@ typedef struct lval_S {
 
 
 static char *e_letunexp = N_("E18: Unexpected characters in :let");
-static char *e_listidx = N_("E684: list index out of range: %" PRId64);
 static char *e_undefvar = N_("E121: Undefined variable: %s");
 static char *e_missbrac = N_("E111: Missing ']'");
 static char *e_listarg = N_("E686: Argument of %s must be a List");
@@ -167,17 +170,21 @@ static char *e_funcexts = N_(
 static char *e_funcdict = N_("E717: Dictionary entry already exists");
 static char *e_funcref = N_("E718: Funcref required");
 static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
-static char *e_letwrong = N_("E734: Wrong variable type for %s=");
 static char *e_nofunc = N_("E130: Unknown function: %s");
 static char *e_illvar = N_("E461: Illegal variable name: %s");
 static char *e_float_as_string = N_("E806: using Float as a String");
 static const char *e_readonlyvar = N_(
     "E46: Cannot change read-only variable \"%.*s\"");
 
-static char_u * const empty_string = (char_u *)"";
+// TODO(ZyX-I): move to eval/executor
+static char *e_letwrong = N_("E734: Wrong variable type for %s=");
+
 static char_u * const namespace_char = (char_u *)"abglstvw";
 
-static dictitem_T globvars_var;                 /* variable used for g: */
+/// Variable used for g:
+static ScopeDictDictItem globvars_var;
+
+/// g: value
 #define globvarht globvardict.dv_hashtab
 
 /*
@@ -188,12 +195,15 @@ static hashtab_T compat_hashtab;
 
 hashtab_T func_hashtab;
 
+// Used for checking if local variables or arguments used in a lambda.
+static int *eval_lavars_used = NULL;
+
 /*
  * Array to hold the hashtab with variables local to each sourced script.
  * Each item holds a variable (nameless) that points to the dict_T.
  */
 typedef struct {
-  dictitem_T sv_var;
+  ScopeDictDictItem sv_var;
   dict_T sv_dict;
 } scriptvar_T;
 
@@ -231,17 +241,44 @@ typedef enum {
 // The names of packages that once were loaded are remembered.
 static garray_T ga_loaded = { 0, 0, sizeof(char_u *), 4, NULL };
 
-// List heads for garbage collection. Although there can be a reference loop
-// from partial to dict to partial, we don't need to keep track of the partial,
-// since it will get freed when the dict is unused and gets freed.
-static dict_T           *first_dict = NULL;     // list of all dicts
-static list_T           *first_list = NULL;     // list of all lists
-
-#define FLEN_FIXED 40
-
 #define FUNCARG(fp, j)  ((char_u **)(fp->uf_args.ga_data))[j]
 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
 
+/// Short variable name length
+#define VAR_SHORT_LEN 20
+/// Number of fixed variables used for arguments
+#define FIXVAR_CNT 12
+
+struct funccall_S {
+  ufunc_T *func;  ///< Function being called.
+  int linenr;  ///< Next line to be executed.
+  int returned;  ///< ":return" used.
+  /// Fixed variables for arguments.
+  TV_DICTITEM_STRUCT(VAR_SHORT_LEN + 1) fixvar[FIXVAR_CNT];
+  dict_T l_vars;  ///< l: local function variables.
+  ScopeDictDictItem l_vars_var;  ///< Variable for l: scope.
+  dict_T l_avars;  ///< a: argument variables.
+  ScopeDictDictItem l_avars_var;  ///< Variable for a: scope.
+  list_T l_varlist;  ///< List for a:000.
+  listitem_T l_listitems[MAX_FUNC_ARGS];  ///< List items for a:000.
+  typval_T *rettv;  ///< Return value.
+  linenr_T breakpoint;  ///< Next line with breakpoint or zero.
+  int dbg_tick;  ///< Debug_tick when breakpoint was set.
+  int level;  ///< Top nesting level of executed function.
+  proftime_T prof_child;  ///< Time spent in a child.
+  funccall_T *caller;  ///< Calling function or NULL.
+  int fc_refcount;  ///< Number of user functions that reference this funccall.
+  int fc_copyID;  ///< CopyID used for garbage collection.
+  garray_T fc_funcs;  ///< List of ufunc_T* which keep a reference to "func".
+};
+
+///< Structure used by trans_function_name()
+typedef struct {
+  dict_T *fd_dict;  ///< Dictionary used.
+  char_u *fd_newkey;  ///< New key in "dict" in allocated memory.
+  dictitem_T  *fd_di;  ///< Dictionary item used.
+} funcdict_T;
+
 /*
  * Info used by a ":for" loop.
  */
@@ -283,8 +320,8 @@ typedef enum {
 // variables with the VV_ defines.
 static struct vimvar {
   char        *vv_name;  ///< Name of the variable, without v:.
-  dictitem16_T vv_di;    ///< Value and name for key (max 16 chars)
-  char vv_flags;         ///< Flags: #VV_COMPAT, #VV_RO, #VV_RO_SBX.
+  TV_DICTITEM_STRUCT(17) vv_di;  ///< Value and name for key (max 16 chars).
+  char vv_flags;  ///< Flags: #VV_COMPAT, #VV_RO, #VV_RO_SBX.
 } vimvars[] =
 {
   // VV_ tails differing from upcased string literals:
@@ -389,7 +426,10 @@ static struct vimvar {
 #define vv_dict         vv_di.di_tv.vval.v_dict
 #define vv_tv           vv_di.di_tv
 
-static dictitem_T vimvars_var;                  // variable used for v:
+/// Variable used for v:
+static ScopeDictDictItem vimvars_var;
+
+/// v: hashtab
 #define vimvarht  vimvardict.dv_hashtab
 
 typedef enum {
@@ -465,6 +505,17 @@ typedef struct fst {
 
 KHASH_MAP_INIT_STR(functions, VimLFuncDef)
 
+/// Type of assert_* check being performed
+typedef enum
+{
+  ASSERT_EQUAL,
+  ASSERT_NOTEQUAL,
+  ASSERT_MATCH,
+  ASSERT_NOTMATCH,
+  ASSERT_INRANGE,
+  ASSERT_OTHER,
+} assert_type_T;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval.c.generated.h"
 #endif
@@ -547,7 +598,7 @@ void eval_init(void)
 
   dict_T *const msgpack_types_dict = dict_alloc();
   for (size_t i = 0; i < ARRAY_SIZE(msgpack_type_names); i++) {
-    list_T *const type_list = list_alloc();
+    list_T *const type_list = tv_list_alloc();
     type_list->lv_lock = VAR_FIXED;
     type_list->lv_refcount = 1;
     dictitem_T *const di = dictitem_alloc((char_u *)msgpack_type_names[i]);
@@ -570,7 +621,7 @@ void eval_init(void)
   dict_T *v_event = dict_alloc();
   v_event->dv_lock = VAR_FIXED;
   set_vim_var_dict(VV_EVENT, v_event);
-  set_vim_var_list(VV_ERRORS, list_alloc());
+  set_vim_var_list(VV_ERRORS, tv_list_alloc());
   set_vim_var_nr(VV_SEARCHFORWARD, 1L);
   set_vim_var_nr(VV_HLSEARCH, 1L);
   set_vim_var_nr(VV_COUNT1, 1);
@@ -601,7 +652,7 @@ void eval_clear(void)
       xfree(p->vv_str);
       p->vv_str = NULL;
     } else if (p->vv_di.di_tv.v_type == VAR_LIST) {
-      list_unref(p->vv_list);
+      tv_list_unref(p->vv_list);
       p->vv_list = NULL;
     }
   }
@@ -832,7 +883,7 @@ void var_redir_stop(void)
 int eval_charconvert(const char *const enc_from, const char *const enc_to,
                      const char *const fname_from, const char *const fname_to)
 {
-  int err = false;
+  bool err = false;
 
   set_vim_var_string(VV_CC_FROM, enc_from, -1);
   set_vim_var_string(VV_CC_TO, enc_to, -1);
@@ -854,7 +905,7 @@ int eval_charconvert(const char *const enc_from, const char *const enc_to,
 
 int eval_printexpr(const char *const fname, const char *const args)
 {
-  int err = false;
+  bool err = false;
 
   set_vim_var_string(VV_FNAME_IN, fname, -1);
   set_vim_var_string(VV_CMDARG, args, -1);
@@ -874,7 +925,7 @@ int eval_printexpr(const char *const fname, const char *const args)
 void eval_diff(const char *const origfile, const char *const newfile,
                const char *const outfile)
 {
-  int err = FALSE;
+  bool err = false;
 
   set_vim_var_string(VV_FNAME_IN, origfile, -1);
   set_vim_var_string(VV_FNAME_NEW, newfile, -1);
@@ -888,7 +939,7 @@ void eval_diff(const char *const origfile, const char *const newfile,
 void eval_patch(const char *const origfile, const char *const difffile,
                 const char *const outfile)
 {
-  int err;
+  bool err = false;
 
   set_vim_var_string(VV_FNAME_IN, origfile, -1);
   set_vim_var_string(VV_FNAME_DIFF, difffile, -1);
@@ -907,27 +958,29 @@ void eval_patch(const char *const origfile, const char *const difffile,
 int 
 eval_to_bool (
     char_u *arg,
-    int *error,
+    bool *error,
     char_u **nextcmd,
     int skip                   /* only parse, don't execute */
 )
 {
   typval_T tv;
-  int retval = FALSE;
+  bool retval = false;
 
-  if (skip)
-    ++emsg_skip;
-  if (eval0(arg, &tv, nextcmd, !skip) == FAIL)
-    *error = TRUE;
-  else {
-    *error = FALSE;
+  if (skip) {
+    emsg_skip++;
+  }
+  if (eval0(arg, &tv, nextcmd, !skip) == FAIL) {
+    *error = true;
+  } else {
+    *error = false;
     if (!skip) {
       retval = (get_tv_number_chk(&tv, error) != 0);
-      clear_tv(&tv);
+      tv_clear(&tv);
     }
   }
-  if (skip)
-    --emsg_skip;
+  if (skip) {
+    emsg_skip--;
+  }
 
   return retval;
 }
@@ -953,7 +1006,7 @@ eval_to_string_skip (
     retval = NULL;
   else {
     retval = vim_strsave(get_tv_string(&tv));
-    clear_tv(&tv);
+    tv_clear(&tv);
   }
   if (skip)
     --emsg_skip;
@@ -992,9 +1045,10 @@ char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert)
     if (convert && tv.v_type == VAR_LIST) {
       ga_init(&ga, (int)sizeof(char), 80);
       if (tv.vval.v_list != NULL) {
-        list_join(&ga, tv.vval.v_list, "\n");
-        if (tv.vval.v_list->lv_len > 0)
+        tv_list_join(&ga, tv.vval.v_list, "\n");
+        if (tv.vval.v_list->lv_len > 0) {
           ga_append(&ga, NL);
+        }
       }
       ga_append(&ga, NUL);
       retval = (char_u *)ga.ga_data;
@@ -1003,7 +1057,7 @@ char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert)
       retval = vim_strsave(numbuf);
     } else
       retval = vim_strsave(get_tv_string(&tv));
-    clear_tv(&tv);
+    tv_clear(&tv);
   }
 
   return retval;
@@ -1047,7 +1101,7 @@ int eval_to_number(char_u *expr)
     retval = -1;
   else {
     retval = get_tv_number_chk(&rettv, NULL);