converter.c File Reference

#include <assert.h>
#include <lauxlib.h>
#include <lua.h>
#include <lualib.h>
#include <stdbool.h>
#include <stdint.h>
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/func_attr.h"
#include "nvim/memory.h"
#include "nvim/ascii.h"
#include "nvim/eval/decode.h"
#include "nvim/eval/typval.h"
#include "nvim/eval/userfunc.h"
#include "nvim/globals.h"
#include "nvim/lib/kvec.h"
#include "nvim/lua/converter.h"
#include "nvim/lua/executor.h"
#include "nvim/macros.h"
#include "nvim/message.h"
#include "nvim/vim.h"
#include "nvim/eval/typval_encode.c.h"

Data Structures
struct	LuaTableProps
	Determine, which keys lua table contains. More...
struct	TVPopStackItem
	Helper structure for nlua_pop_typval. More...
struct	ObjPopStackItem
	Helper structure for nlua_pop_Object. More...

Macros
#define	TYPE_IDX_VALUE   true
#define	VAL_IDX_VALUE   false
#define	LUA_PUSH_STATIC_STRING(lstate, s)   lua_pushlstring(lstate, s, sizeof(s) - 1)
#define	TYPVAL_ENCODE_ALLOW_SPECIALS   true
#define	TYPVAL_ENCODE_CONV_NIL(tv)
#define	TYPVAL_ENCODE_CONV_BOOL(tv, num)   lua_pushboolean(lstate, (bool)(num))
#define	TYPVAL_ENCODE_CONV_NUMBER(tv, num)   lua_pushnumber(lstate, (lua_Number)(num))
#define	TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER   TYPVAL_ENCODE_CONV_NUMBER
#define	TYPVAL_ENCODE_CONV_FLOAT(tv, flt)   TYPVAL_ENCODE_CONV_NUMBER(tv, flt)
#define	TYPVAL_ENCODE_CONV_STRING(tv, str, len)   lua_pushlstring(lstate, (const char *)(str), (len))
#define	TYPVAL_ENCODE_CONV_STR_STRING   TYPVAL_ENCODE_CONV_STRING
#define	TYPVAL_ENCODE_CONV_EXT_STRING(tv, str, len, type)   TYPVAL_ENCODE_CONV_NIL(tv)
#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)
#define	TYPVAL_ENCODE_CONV_EMPTY_LIST(tv)   lua_createtable(lstate, 0, 0)
#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)   lua_rawset(lstate, -3)
#define	TYPVAL_ENCODE_CONV_DICT_START(tv, dict, len)
#define	TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK(label, kv_pair)
#define	TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, dict, mpsv)
#define	TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(tv, dict)
#define	TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict)   lua_rawset(lstate, -3)
#define	TYPVAL_ENCODE_CONV_DICT_END(tv, dict)   TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict)
#define	TYPVAL_ENCODE_CONV_RECURSE(val, conv_type)
#define	TYPVAL_ENCODE_SCOPE   static
#define	TYPVAL_ENCODE_NAME   lua
#define	TYPVAL_ENCODE_FIRST_ARG_TYPE   lua_State *const
#define	TYPVAL_ENCODE_FIRST_ARG_NAME   lstate
#define	GENERATE_INDEX_FUNCTION(type)
#define	ADD_TYPE(type, data_key)
#define	ADD_REMOTE_TYPE(type)
#define	GENERATE_INDEX_FUNCTION(type)

Functions
bool	nlua_pop_typval (lua_State *lstate, typval_T *ret_tv)
bool	nlua_push_typval (lua_State *lstate, typval_T *const tv, bool special)
void	nlua_push_String (lua_State *lstate, const String s, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Integer (lua_State *lstate, const Integer n, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Float (lua_State *lstate, const Float f, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Boolean (lua_State *lstate, const Boolean b, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Dictionary (lua_State *lstate, const Dictionary dict, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Array (lua_State *lstate, const Array array, bool special) FUNC_ATTR_NONNULL_ALL
void	nlua_push_Object (lua_State *lstate, const Object obj, bool special) FUNC_ATTR_NONNULL_ALL
String	nlua_pop_String (lua_State *lstate, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Integer	nlua_pop_Integer (lua_State *lstate, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Boolean	nlua_pop_Boolean (lua_State *lstate, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Float	nlua_pop_Float (lua_State *lstate, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Array	nlua_pop_Array (lua_State *lstate, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Dictionary	nlua_pop_Dictionary (lua_State *lstate, bool ref, Error *err) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
Object	nlua_pop_Object (lua_State *const lstate, bool ref, Error *const err)
LuaRef	nlua_pop_LuaRef (lua_State *const lstate, Error *err)
void	nlua_init_types (lua_State *const lstate)
void	nlua_pop_keydict (lua_State *L, void *retval, field_hash hashy, Error *err)

Macro Definition Documentation

ADD_REMOTE_TYPE

#define ADD_REMOTE_TYPE

(

type

)

Value:

  case kObjectType##type: { \
      nlua_push_##type(lstate, (type)obj.data.integer, special); \
      break; \
  }

ADD_TYPE

#define ADD_TYPE	(		type,
			data_key
	)

Value:

  case kObjectType##type: { \
      nlua_push_##type(lstate, obj.data.data_key, special); \
      break; \
  }

GENERATE_INDEX_FUNCTION [1/2]

#define GENERATE_INDEX_FUNCTION

(

type

)

Value:

  void nlua_push_##type(lua_State *lstate, const type item, bool special) \
  FUNC_ATTR_NONNULL_ALL \
  { \
    lua_pushnumber(lstate, (lua_Number)(item)); \
  }

GENERATE_INDEX_FUNCTION [2/2]

#define GENERATE_INDEX_FUNCTION

(

type

)

Value:

  type nlua_pop_##type(lua_State *lstate, Error *err) \
  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT \
  { \
    type ret; \
    if (lua_type(lstate, -1) != LUA_TNUMBER) { \
      api_set_error(err, kErrorTypeValidation, "Expected Lua number"); \
      ret = (type) - 1; \
    } else { \
      ret = (type)lua_tonumber(lstate, -1); \
    } \
    lua_pop(lstate, 1); \
    return ret; \
  }

LUA_PUSH_STATIC_STRING

#define LUA_PUSH_STATIC_STRING	(		lstate,
			s
	)		lua_pushlstring(lstate, s, sizeof(s) - 1)

TYPE_IDX_VALUE

#define TYPE_IDX_VALUE   true

TYPVAL_ENCODE_ALLOW_SPECIALS

#define TYPVAL_ENCODE_ALLOW_SPECIALS   true

TYPVAL_ENCODE_CONV_BLOB

#define TYPVAL_ENCODE_CONV_BLOB	(		tv,
			blob,
			len
	)

Value:

  do { \
    const blob_T *const blob_ = (blob); \
    lua_pushlstring(lstate, \
                    blob_ != NULL ? (const char *)blob_->bv_ga.ga_data : "", \
                    (size_t)(len)); \
  } while (0)

TYPVAL_ENCODE_CONV_BOOL

#define TYPVAL_ENCODE_CONV_BOOL	(		tv,
			num
	)		lua_pushboolean(lstate, (bool)(num))

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
	)		lua_rawset(lstate, -3)

TYPVAL_ENCODE_CONV_DICT_END

#define TYPVAL_ENCODE_CONV_DICT_END	(		tv,
			dict
	)		TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict)

TYPVAL_ENCODE_CONV_DICT_START

#define TYPVAL_ENCODE_CONV_DICT_START	(		tv,
			dict,
			len
	)

Value:

  do { \
    if (!lua_checkstack(lstate, lua_gettop(lstate) + 3)) { \
      semsg(_("E5102: Lua failed to grow stack to %i"), \
            lua_gettop(lstate) + 3); \
      return false; \
    } \
    lua_createtable(lstate, 0, (int)(len)); \
  } while (0)

TYPVAL_ENCODE_CONV_EMPTY_DICT

#define TYPVAL_ENCODE_CONV_EMPTY_DICT	(		tv,
			dict
	)

Value:

  do { \
    if (typval_conv_special) { \
      nlua_create_typed_table(lstate, 0, 0, kObjectTypeDictionary); \
    } else { \
      lua_createtable(lstate, 0, 0); \
      nlua_pushref(lstate, nlua_global_refs->empty_dict_ref); \
      lua_setmetatable(lstate, -2); \
    } \
  } while (0)

TYPVAL_ENCODE_CONV_EMPTY_LIST

#define TYPVAL_ENCODE_CONV_EMPTY_LIST

(

tv

)

lua_createtable(lstate, 0, 0)

TYPVAL_ENCODE_CONV_EXT_STRING

#define TYPVAL_ENCODE_CONV_EXT_STRING	(		tv,
			str,
			len,
			type
	)		TYPVAL_ENCODE_CONV_NIL(tv)

TYPVAL_ENCODE_CONV_FLOAT

#define TYPVAL_ENCODE_CONV_FLOAT	(		tv,
			flt
	)		TYPVAL_ENCODE_CONV_NUMBER(tv, flt)

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

)

TYPVAL_ENCODE_CONV_FUNC_START

#define TYPVAL_ENCODE_CONV_FUNC_START	(		tv,
			fun
	)

Value:

  do { \
    ufunc_T *fp = find_func(fun); \
    if (fp != NULL && fp->uf_cb == nlua_CFunction_func_call) { \
      nlua_pushref(lstate, ((LuaCFunctionState *)fp->uf_cb_state)->lua_callable.func_ref); \
    } else { \
      TYPVAL_ENCODE_CONV_NIL(tv); \
    } \
    goto typval_encode_stop_converting_one_item; \
  } while (0)

TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS

#define TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS

(

tv

)

Value:

  do { \
    lua_Number idx = lua_tonumber(lstate, -2); \
    lua_rawset(lstate, -3); \
    lua_pushnumber(lstate, idx + 1); \
  } while (0)

TYPVAL_ENCODE_CONV_LIST_END

#define TYPVAL_ENCODE_CONV_LIST_END

(

tv

)

lua_rawset(lstate, -3)

TYPVAL_ENCODE_CONV_LIST_START

#define TYPVAL_ENCODE_CONV_LIST_START	(		tv,
			len
	)

Value:

  do { \
    if (!lua_checkstack(lstate, lua_gettop(lstate) + 3)) { \
      semsg(_("E5102: Lua failed to grow stack to %i"), \
            lua_gettop(lstate) + 3); \
      return false; \
    } \
    lua_createtable(lstate, (int)(len), 0); \
    lua_pushnumber(lstate, 1); \
  } while (0)

TYPVAL_ENCODE_CONV_NIL

#define TYPVAL_ENCODE_CONV_NIL

(

tv

)

Value:

  do { \
    if (typval_conv_special) { \
      lua_pushnil(lstate); \
    } else { \
      nlua_pushref(lstate, nlua_global_refs->nil_ref); \
    } \
  } while (0)

TYPVAL_ENCODE_CONV_NUMBER

#define TYPVAL_ENCODE_CONV_NUMBER	(		tv,
			num
	)		lua_pushnumber(lstate, (lua_Number)(num))

TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START

#define TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START	(		tv,
			dict,
			mpsv
	)

TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START

#define TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START	(		tv,
			mpsv
	)

TYPVAL_ENCODE_CONV_RECURSE

#define TYPVAL_ENCODE_CONV_RECURSE	(		val,
			conv_type
	)

Value:

  do { \
    for (size_t backref = kv_size(*mpstack); backref; backref--) { \
      const MPConvStackVal mpval = kv_A(*mpstack, backref - 1); \
      if (mpval.type == conv_type) { \
        if (conv_type == kMPConvDict \
            ? (void *)mpval.data.d.dict == (void *)(val) \
            : (void *)mpval.data.l.list == (void *)(val)) { \
          lua_pushvalue(lstate, \
                        -((int)((kv_size(*mpstack) - backref + 1) * 2))); \
          break; \
        } \
      } \
    } \
  } while (0)

TYPVAL_ENCODE_CONV_STR_STRING

#define TYPVAL_ENCODE_CONV_STR_STRING   TYPVAL_ENCODE_CONV_STRING

TYPVAL_ENCODE_CONV_STRING

#define TYPVAL_ENCODE_CONV_STRING	(		tv,
			str,
			len
	)		lua_pushlstring(lstate, (const char *)(str), (len))

TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER

#define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER   TYPVAL_ENCODE_CONV_NUMBER

TYPVAL_ENCODE_FIRST_ARG_NAME

#define TYPVAL_ENCODE_FIRST_ARG_NAME   lstate

TYPVAL_ENCODE_FIRST_ARG_TYPE

#define TYPVAL_ENCODE_FIRST_ARG_TYPE   lua_State *const

TYPVAL_ENCODE_NAME

#define TYPVAL_ENCODE_NAME   lua

TYPVAL_ENCODE_SCOPE

#define TYPVAL_ENCODE_SCOPE   static

TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK

#define TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK	(		label,
			kv_pair
	)

VAL_IDX_VALUE

#define VAL_IDX_VALUE   false

Function Documentation

nlua_init_types()

void nlua_init_types

(

lua_State *const

lstate

)

Record some auxiliary values in vim module

Assumes that module table is on top of the stack.

Recorded values:

vim.type_idx:

See also

nlua_push_type_idx() vim.val_idx:

nlua_push_val_idx() vim.types: table mapping possible values of vim.type_idx to string names (i.e. array, float, dictionary) and back.

nlua_pop_Array()

Array nlua_pop_Array	(	lua_State *	lstate,
		Error *	err
	)

Convert lua table to array

Always pops one value from the stack.

nlua_pop_Boolean()

Boolean nlua_pop_Boolean	(	lua_State *	lstate,
		Error *	err
	)

Convert lua value to boolean

Always pops one value from the stack.

nlua_pop_Dictionary()

Dictionary nlua_pop_Dictionary	(	lua_State *	lstate,
		bool	ref,
		Error *	err
	)

Convert lua table to dictionary

Always pops one value from the stack.

nlua_pop_Float()

Float nlua_pop_Float	(	lua_State *	lstate,
		Error *	err
	)

Convert lua table to float

Always pops one value from the stack.

nlua_pop_Integer()

Integer nlua_pop_Integer	(	lua_State *	lstate,
		Error *	err
	)

Convert lua value to integer

Always pops one value from the stack.

nlua_pop_keydict()

void nlua_pop_keydict	(	lua_State *	L,
		void *	retval,
		field_hash	hashy,
		Error *	err
	)

nlua_pop_LuaRef()

LuaRef nlua_pop_LuaRef	(	lua_State *const	lstate,
		Error *	err
	)

nlua_pop_Object()

Object nlua_pop_Object	(	lua_State *const	lstate,
		bool	ref,
		Error *const	err
	)

Convert lua table to object

Always pops one value from the stack.

nlua_pop_String()

String nlua_pop_String	(	lua_State *	lstate,
		Error *	err
	)

Convert lua value to string

Always pops one value from the stack.

nlua_pop_typval()

bool nlua_pop_typval	(	lua_State *	lstate,
		typval_T *	ret_tv
	)

Convert lua object to VimL typval_T

Should pop exactly one value from lua stack.

Parameters

	lstate	Lua state.
[out]	ret_tv	Where to put the result.

Returns

true in case of success, false in case of failure. Error is reported automatically.

nlua_push_Array()

void nlua_push_Array	(	lua_State *	lstate,
		const Array	array,
		bool	special
	)

Convert given Array to lua table

Leaves converted table on top of the stack.

nlua_push_Boolean()

void nlua_push_Boolean	(	lua_State *	lstate,
		const Boolean	b,
		bool	special
	)

Convert given Float to lua boolean

Leaves converted value on top of the stack.

nlua_push_Dictionary()

void nlua_push_Dictionary	(	lua_State *	lstate,
		const Dictionary	dict,
		bool	special
	)

Convert given Dictionary to lua table

Leaves converted table on top of the stack.

nlua_push_Float()

void nlua_push_Float	(	lua_State *	lstate,
		const Float	f,
		bool	special
	)

Convert given Float to lua table

Leaves converted table on top of the stack.

nlua_push_Integer()

void nlua_push_Integer	(	lua_State *	lstate,
		const Integer	n,
		bool	special
	)

Convert given Integer to lua number

Leaves converted number on top of the stack.

nlua_push_Object()

void nlua_push_Object	(	lua_State *	lstate,
		const Object	obj,
		bool	special
	)

Convert given Object to lua value

Leaves converted value on top of the stack.

nlua_push_String()

void nlua_push_String	(	lua_State *	lstate,
		const String	s,
		bool	special
	)

Convert given String to lua string

Leaves converted string on top of the stack.

nlua_push_typval()

bool nlua_push_typval	(	lua_State *	lstate,
		typval_T *const	tv,
		bool	special
	)

Convert VimL typval_T to lua value

Should leave single value in lua stack. May only fail if lua failed to grow stack.

Parameters

	lstate	Lua interpreter state.
[in]	tv	typval_T to convert.

Returns

true in case of success, false otherwise.