typval.h

Go to the documentation of this file.

#ifndef NVIM_EVAL_TYPVAL_H
#define NVIM_EVAL_TYPVAL_H
 
#include <assert.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
 
#include "nvim/func_attr.h"
#include "nvim/garray.h"
#include "nvim/gettext.h"
#include "nvim/hashtab.h"
#include "nvim/lib/queue.h"
#include "nvim/macros.h"
#include "nvim/mbyte.h"
#include "nvim/message.h"
#include "nvim/pos.h"      // for linenr_T
#include "nvim/profile.h"  // for proftime_T
#include "nvim/types.h"
#ifdef LOG_LIST_ACTIONS
# include "nvim/memory.h"
#endif
 
typedef int64_t varnumber_T;
typedef uint64_t uvarnumber_T;
 
typedef double float_T;
 
enum { DO_NOT_FREE_CNT = (INT_MAX / 2), };
 
enum ListLenSpecials {
  kListLenUnknown = -1,
  kListLenShouldKnow = -2,
  kListLenMayKnow = -3,
};
 
#define VARNUMBER_MAX INT64_MAX
#define UVARNUMBER_MAX UINT64_MAX
 
#define VARNUMBER_MIN INT64_MIN
 
#define PRIdVARNUMBER PRId64
 
typedef struct listvar_S list_T;
typedef struct dictvar_S dict_T;
typedef struct partial_S partial_T;
typedef struct blobvar_S blob_T;
 
typedef struct ufunc ufunc_T;
 
typedef enum {
  kCallbackNone = 0,
  kCallbackFuncref,
  kCallbackPartial,
} CallbackType;
 
typedef struct {
  union {
    char_u *funcref;
    partial_T *partial;
  } data;
  CallbackType type;
} Callback;
#define CALLBACK_NONE ((Callback){ .type = kCallbackNone })
 
typedef struct dict_watcher {
  Callback callback;
  char *key_pattern;
  size_t key_pattern_len;
  QUEUE node;
  bool busy;  // prevent recursion if the dict is changed in the callback
  bool needs_free;
} DictWatcher;
 
typedef enum {
  kBoolVarFalse,         
  kBoolVarTrue,          
} BoolVarValue;
 
typedef enum {
  kSpecialVarNull,   
} SpecialVarValue;
 
typedef enum {
  VAR_UNLOCKED = 0,  
  VAR_LOCKED = 1,    
  VAR_FIXED = 2,     
} VarLockStatus;
 
typedef enum {
  VAR_UNKNOWN = 0,  
  VAR_NUMBER,       
  VAR_STRING,       
  VAR_FUNC,         
  VAR_LIST,         
  VAR_DICT,         
  VAR_FLOAT,        
  VAR_BOOL,         
  VAR_SPECIAL,      
  VAR_PARTIAL,      
  VAR_BLOB,         
} VarType;
 
typedef struct {
  VarType v_type;  
  VarLockStatus v_lock;  
  union typval_vval_union {
    varnumber_T v_number;  
    BoolVarValue v_bool;        
    SpecialVarValue v_special;  
    float_T v_float;  
    char_u *v_string;  
    list_T *v_list;  
    dict_T *v_dict;  
    partial_T *v_partial;  
    blob_T *v_blob;  
  } vval;  
} typval_T;
 
typedef enum {
  VAR_NO_SCOPE = 0,  
  VAR_SCOPE = 1,  
  VAR_DEF_SCOPE = 2,  
} ScopeType;
 
typedef struct listitem_S listitem_T;
 
struct listitem_S {
  listitem_T *li_next;  
  listitem_T *li_prev;  
  typval_T li_tv;  
};
 
typedef struct listwatch_S listwatch_T;
 
struct listwatch_S {
  listitem_T *lw_item;  
  listwatch_T *lw_next;  
};
 
struct listvar_S {
  listitem_T *lv_first;  
  listitem_T *lv_last;  
  listwatch_T *lv_watch;  
  listitem_T *lv_idx_item;  
  list_T *lv_copylist;  
  list_T *lv_used_next;  
  list_T *lv_used_prev;  
  int lv_refcount;  
  int lv_len;  
  int lv_idx;  
  int lv_copyID;  
  VarLockStatus lv_lock;  
 
  LuaRef lua_table_ref;
};
 
// Static list with 10 items. Use tv_list_init_static10() to initialize.
typedef struct {
  list_T sl_list;  // must be first
  listitem_T sl_items[10];
} staticList10_T;
 
#define TV_LIST_STATIC10_INIT { \
  .sl_list = { \
  .lv_first = NULL, \
  .lv_last = NULL, \
  .lv_refcount = 0, \
  .lv_len = 0, \
  .lv_watch = NULL, \
  .lv_idx_item = NULL, \
  .lv_lock = VAR_FIXED, \
  .lv_used_next = NULL, \
  .lv_used_prev = NULL, \
  }, \
}
 
#define TV_DICTITEM_STRUCT(...) \
  struct { \
    typval_T di_tv;  /* Structure that holds scope dictionary itself. */ \
    uint8_t di_flags;  /* Flags. */ \
    char_u di_key[__VA_ARGS__];  /* Key value. */ \
  }
 
typedef TV_DICTITEM_STRUCT(1) ScopeDictDictItem;
 
typedef TV_DICTITEM_STRUCT() dictitem_T;
 
typedef enum {
  DI_FLAGS_RO = 1,  
  DI_FLAGS_RO_SBX = 2,  
  DI_FLAGS_FIX = 4,  
  DI_FLAGS_LOCK = 8,  
  DI_FLAGS_ALLOC = 16,  
} DictItemFlags;
 
struct dictvar_S {
  VarLockStatus dv_lock;  
  ScopeType dv_scope;     
  int dv_refcount;        
  int dv_copyID;          
  hashtab_T dv_hashtab;   
  dict_T *dv_copydict;    
  dict_T *dv_used_next;   
  dict_T *dv_used_prev;   
  QUEUE watchers;         
 
  LuaRef lua_table_ref;
};
 
struct blobvar_S {
  garray_T bv_ga;         
  int bv_refcount;        
  VarLockStatus bv_lock;  
};
 
typedef int scid_T;
#define PRIdSCID "d"
 
// SCript ConteXt (SCTX): identifies a script line.
// When sourcing a script "sc_lnum" is zero, "sourcing_lnum" is the current
// line number. When executing a user function "sc_lnum" is the line where the
// function was defined, "sourcing_lnum" is the line number inside the
// function.  When stored with a function, mapping, option, etc. "sc_lnum" is
// the line number in the script "sc_sid".
typedef struct {
  scid_T sc_sid;     // script ID
  int sc_seq;        // sourcing sequence number
  linenr_T sc_lnum;  // line number
} sctx_T;
 
#define MAX_FUNC_ARGS   20
#define VAR_SHORT_LEN 20
#define FIXVAR_CNT 12
 
typedef int (*cfunc_T)(int argcount, typval_T *argvars, typval_T *rettv, void *state);  // NOLINT
typedef void (*cfunc_free_T)(void *state);
 
// Structure to hold info for a function that is currently being executed.
typedef struct funccall_S funccall_T;
 
struct funccall_S {
  ufunc_T *func;  
  int linenr;  
  int returned;  
  TV_DICTITEM_STRUCT(VAR_SHORT_LEN + 1) fixvar[FIXVAR_CNT];
  dict_T l_vars;  
  ScopeDictDictItem l_vars_var;  
  dict_T l_avars;  
  ScopeDictDictItem l_avars_var;  
  list_T l_varlist;  
  listitem_T l_listitems[MAX_FUNC_ARGS];  
  typval_T *rettv;  
  linenr_T breakpoint;  
  int dbg_tick;  
  int level;  
  proftime_T prof_child;  
  funccall_T *caller;  
  int fc_refcount;  
  int fc_copyID;  
  garray_T fc_funcs;  
};
 
struct ufunc {
  int uf_varargs;       
  int uf_flags;
  int uf_calls;         
  bool uf_cleared;       
  garray_T uf_args;          
  garray_T uf_def_args;      
  garray_T uf_lines;         
  int uf_profiling;     
  int uf_prof_initialized;
  // Managing cfuncs
  cfunc_T uf_cb;            
  cfunc_free_T uf_cb_free;       
  void *uf_cb_state;      
  // Profiling the function as a whole.
  int uf_tm_count;      
  proftime_T uf_tm_total;      
  proftime_T uf_tm_self;       
  proftime_T uf_tm_children;   
  // Profiling the function per line.
  int *uf_tml_count;     
  proftime_T *uf_tml_total;     
  proftime_T *uf_tml_self;      
  proftime_T uf_tml_start;     
  proftime_T uf_tml_children;  
  proftime_T uf_tml_wait;      
  int uf_tml_idx;       
  int uf_tml_execed;    
  sctx_T uf_script_ctx;    
  int uf_refcount;      
  funccall_T *uf_scoped;       
  char_u uf_name[];  
};
 
struct partial_S {
  int pt_refcount;  
  char_u *pt_name;  
  ufunc_T *pt_func;  
  bool pt_auto;  
  int pt_argc;  
  typval_T *pt_argv;  
  dict_T *pt_dict;  
};
 
typedef struct ht_stack_S {
  hashtab_T *ht;
  struct ht_stack_S *prev;
} ht_stack_T;
 
typedef struct list_stack_S {
  list_T *list;
  struct list_stack_S *prev;
} list_stack_T;
 
typedef struct {
  listitem_T *item;  
  int idx;  
} ListSortItem;
 
typedef int (*ListSorter)(const void *, const void *);
 
#ifdef LOG_LIST_ACTIONS
 
typedef struct {
  uintptr_t l;  
  uintptr_t li1;  
  uintptr_t li2;  
  int len;  
  const char *action;  
} ListLogEntry;
 
typedef struct list_log ListLog;
 
struct list_log {
  ListLog *next;  
  size_t capacity;  
  size_t size;  
  ListLogEntry entries[];  
};
 
extern ListLog *list_log_first;  
extern ListLog *list_log_last;  
 
static inline ListLog *list_log_alloc(const size_t size)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline ListLog *list_log_new(const size_t size)
{
  ListLog *ret = xmalloc(offsetof(ListLog, entries)
                         + size * sizeof(ret->entries[0]));
  ret->size = 0;
  ret->capacity = size;
  ret->next = NULL;
  if (list_log_first == NULL) {
    list_log_first = ret;
  } else {
    list_log_last->next = ret;
  }
  list_log_last = ret;
  return ret;
}
 
static inline void list_log(const list_T *const l,
                            const listitem_T *const li1,
                            const listitem_T *const li2,
                            const char *const action)
  REAL_FATTR_ALWAYS_INLINE;
 
static inline void list_log(const list_T *const l, const listitem_T *const li1,
                            const listitem_T *const li2, const char *const action)
{
  ListLog *tgt;
  if (list_log_first == NULL) {
    tgt = list_log_new(128);
  } else if (list_log_last->size == list_log_last->capacity) {
    tgt = list_log_new(list_log_last->capacity * 2);
  } else {
    tgt = list_log_last;
  }
  tgt->entries[tgt->size++] = (ListLogEntry) {
    .l = (uintptr_t)l,
    .li1 = (uintptr_t)li1,
    .li2 = (uintptr_t)li2,
    .len = (l == NULL ? 0 : l->lv_len),
    .action = action,
  };
}
#else
# define list_log(...)
# define list_write_log(...)
# define list_free_log()
#endif
 
// In a hashtab item "hi_key" points to "di_key" in a dictitem.
// This avoids adding a pointer to the hashtab item.
 
#define TV_DICT_HI2DI(hi) \
  ((dictitem_T *)((hi)->hi_key - offsetof(dictitem_T, di_key)))
 
static inline void tv_list_ref(list_T *const l)
  REAL_FATTR_ALWAYS_INLINE;
 
static inline void tv_list_ref(list_T *const l)
{
  if (l == NULL) {
    return;
  }
  l->lv_refcount++;
}
 
static inline void tv_list_set_ret(typval_T *const tv, list_T *const l)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ARG(1);
 
static inline void tv_list_set_ret(typval_T *const tv, list_T *const l)
{
  tv->v_type = VAR_LIST;
  tv->vval.v_list = l;
  tv_list_ref(l);
}
 
static inline VarLockStatus tv_list_locked(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline VarLockStatus tv_list_locked(const list_T *const l)
{
  if (l == NULL) {
    return VAR_FIXED;
  }
  return l->lv_lock;
}
 
static inline void tv_list_set_lock(list_T *const l, const VarLockStatus lock)
{
  if (l == NULL) {
    assert(lock == VAR_FIXED);
    return;
  }
  l->lv_lock = lock;
}
 
static inline void tv_list_set_copyid(list_T *const l, const int copyid)
  FUNC_ATTR_NONNULL_ALL
{
  l->lv_copyID = copyid;
}
 
static inline int tv_list_len(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline int tv_list_len(const list_T *const l)
{
  list_log(l, NULL, NULL, "len");
  if (l == NULL) {
    return 0;
  }
  return l->lv_len;
}
 
static inline int tv_list_copyid(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT REAL_FATTR_NONNULL_ALL;
 
static inline int tv_list_copyid(const list_T *const l)
{
  return l->lv_copyID;
}
 
static inline list_T *tv_list_latest_copy(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT REAL_FATTR_NONNULL_ALL;
 
static inline list_T *tv_list_latest_copy(const list_T *const l)
{
  return l->lv_copylist;
}
 
static inline int tv_list_uidx(const list_T *const l, int n)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline int tv_list_uidx(const list_T *const l, int n)
{
  // Negative index is relative to the end.
  if (n < 0) {
    n += tv_list_len(l);
  }
 
  // Check for index out of range.
  if (n < 0 || n >= tv_list_len(l)) {
    return -1;
  }
  return n;
}
 
static inline bool tv_list_has_watchers(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline bool tv_list_has_watchers(const list_T *const l)
{
  return l && l->lv_watch;
}
 
static inline listitem_T *tv_list_first(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline listitem_T *tv_list_first(const list_T *const l)
{
  if (l == NULL) {
    list_log(l, NULL, NULL, "first");
    return NULL;
  }
  list_log(l, l->lv_first, NULL, "first");
  return l->lv_first;
}
 
static inline listitem_T *tv_list_last(const list_T *const l)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline listitem_T *tv_list_last(const list_T *const l)
{
  if (l == NULL) {
    list_log(l, NULL, NULL, "last");
    return NULL;
  }
  list_log(l, l->lv_last, NULL, "last");
  return l->lv_last;
}
 
static inline void tv_dict_set_ret(typval_T *const tv, dict_T *const d)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ARG(1);
 
static inline void tv_dict_set_ret(typval_T *const tv, dict_T *const d)
{
  tv->v_type = VAR_DICT;
  tv->vval.v_dict = d;
  if (d != NULL) {
    d->dv_refcount++;
  }
}
 
static inline long tv_dict_len(const dict_T *const d)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline long tv_dict_len(const dict_T *const d)
{
  if (d == NULL) {
    return 0L;
  }
  return (long)d->dv_hashtab.ht_used;
}
 
static inline bool tv_dict_is_watched(const dict_T *const d)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline bool tv_dict_is_watched(const dict_T *const d)
{
  return d && !QUEUE_EMPTY(&d->watchers);
}
 
static inline void tv_blob_set_ret(typval_T *const tv, blob_T *const b)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ARG(1);
 
static inline void tv_blob_set_ret(typval_T *const tv, blob_T *const b)
{
  tv->v_type = VAR_BLOB;
  tv->vval.v_blob = b;
  if (b != NULL) {
    b->bv_refcount++;
  }
}
 
static inline int tv_blob_len(const blob_T *const b)
  REAL_FATTR_PURE REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline int tv_blob_len(const blob_T *const b)
{
  if (b == NULL) {
    return 0;
  }
  return b->bv_ga.ga_len;
}
 
static inline char_u tv_blob_get(const blob_T *const b, int idx)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ALL REAL_FATTR_WARN_UNUSED_RESULT;
 
static inline char_u tv_blob_get(const blob_T *const b, int idx)
{
  return ((char_u *)b->bv_ga.ga_data)[idx];
}
 
static inline void tv_blob_set(blob_T *const b, int idx, char_u c)
  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ALL;
 
static inline void tv_blob_set(blob_T *const b, int idx, char_u c)
{
  ((char_u *)b->bv_ga.ga_data)[idx] = c;
}
 
static inline void tv_init(typval_T *const tv)
{
  if (tv != NULL) {
    memset(tv, 0, sizeof(*tv));
  }
}
 
#define TV_INITIAL_VALUE \
  ((typval_T) { \
    .v_type = VAR_UNKNOWN, \
    .v_lock = VAR_UNLOCKED, \
  })
 
extern const char *const tv_empty_string;
 
extern bool tv_in_free_unref_items;
 
#define _TV_LIST_ITER_MOD(modifier, l, li, code) \
  do { \
    modifier list_T *const l_ = (l); \
    list_log(l_, NULL, NULL, "iter" #modifier); \
    if (l_ != NULL) { \
      for (modifier listitem_T *li = l_->lv_first; \
           li != NULL; li = li->li_next) { \
        code \
      } \
    } \
  } while (0)
 
#define TV_LIST_ITER(l, li, code) \
  _TV_LIST_ITER_MOD( , l, li, code)
 
#define TV_LIST_ITER_CONST(l, li, code) \
  _TV_LIST_ITER_MOD(const, l, li, code)
 
// Below macros are macros to avoid duplicating code for functionally identical
// const and non-const function variants.
 
#define TV_LIST_ITEM_TV(li) (&(li)->li_tv)
 
#define TV_LIST_ITEM_NEXT(l, li) ((li)->li_next)
 
#define TV_LIST_ITEM_PREV(l, li) ((li)->li_prev)
// List argument is not used currently, but it is a must for lists implemented
// as a pair (size(in list), array) without terminator - basically for lists on
// top of kvec.
 
#define TV_DICT_ITER(d, di, code) \
  HASHTAB_ITER(&(d)->dv_hashtab, di##hi_, { \
    { \
      dictitem_T *const di = TV_DICT_HI2DI(di##hi_); \
      { \
        code \
      } \
    } \
  })
 
static inline bool tv_get_float_chk(const typval_T *const tv,
                                    float_T *const ret_f)
  REAL_FATTR_NONNULL_ALL REAL_FATTR_WARN_UNUSED_RESULT;
 
// FIXME circular dependency, cannot import message.h.
bool semsg(const char *const fmt, ...);
 
static inline bool tv_get_float_chk(const typval_T *const tv, float_T *const ret_f)
{
  if (tv->v_type == VAR_FLOAT) {
    *ret_f = tv->vval.v_float;
    return true;
  }
  if (tv->v_type == VAR_NUMBER) {
    *ret_f = (float_T)tv->vval.v_number;
    return true;
  }
  semsg("%s", _("E808: Number or Float required"));
  return false;
}
 
static inline DictWatcher *tv_dict_watcher_node_data(QUEUE *q)
  REAL_FATTR_NONNULL_ALL REAL_FATTR_NONNULL_RET REAL_FATTR_PURE
  REAL_FATTR_WARN_UNUSED_RESULT REAL_FATTR_ALWAYS_INLINE;
 
static inline DictWatcher *tv_dict_watcher_node_data(QUEUE *q)
{
  return QUEUE_DATA(q, DictWatcher, node);
}
 
static inline bool tv_is_func(const typval_T tv)
  FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_CONST;
 
static inline bool tv_is_func(const typval_T tv)
{
  return tv.v_type == VAR_FUNC || tv.v_type == VAR_PARTIAL;
}
 
#define TV_TRANSLATE (SIZE_MAX)
 
#define TV_CSTRING (SIZE_MAX - 1)
 
#ifdef UNIT_TESTING
// Do not use enum constants, see commit message.
EXTERN const size_t kTVCstring INIT(= TV_CSTRING);
EXTERN const size_t kTVTranslate INIT(= TV_TRANSLATE);
#endif
 
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "eval/typval.h.generated.h"
#endif
#endif  // NVIM_EVAL_TYPVAL_H