IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

*: Make ShaDa code use VimL values for additional_\* data

Browse Source
This commit is contained in:
ZyX 2015-08-03 23:06:06 +03:00
parent 56174572bc
commit 07d9ab26c6
17 changed files with 304 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/nvim/buffer.c
View File

@ -30,7 +30,6 @@
#include <inttypes.h>
#include "nvim/api/private/handle.h"
#include "nvim/api/private/helpers.h"
#include "nvim/ascii.h"
#include "nvim/vim.h"
#include "nvim/buffer.h"
@ -557,10 +556,7 @@ static void free_buffer(buf_T *buf)
free_buffer_stuff(buf, TRUE);
unref_var_dict(buf->b_vars);
aubuflocal_remove(buf);
if (buf->additional_data != NULL) {
api_free_dictionary(*buf->additional_data);
xfree(buf->additional_data);
}
dict_unref(buf->additional_data);
free_fmark(buf->b_last_cursor);
free_fmark(buf->b_last_insert);
free_fmark(buf->b_last_change);

4
src/nvim/buffer_defs.h
View File

@ -26,7 +26,7 @@ typedef struct file_buffer buf_T; // Forward declaration
#include "nvim/eval_defs.h"
// for proftime_T
#include "nvim/profile.h"
// for String and Dictionary
// for String
#include "nvim/api/private/defs.h"
#define MODIFIABLE(buf) (!buf->terminal && buf->b_p_ma)
@ -749,7 +749,7 @@ struct file_buffer {
Terminal *terminal; // Terminal instance associated with the buffer
Dictionary *additional_data; // Additional data from shada file if any.
dict_T *additional_data; // Additional data from shada file if any.
};
/*

144
src/nvim/eval.c
View File

@ -107,18 +107,6 @@
#define AUTOLOAD_CHAR '#' /* Character used as separator in autoload
function/variable names. */
/*
* In a hashtab item "hi_key" points to "di_key" in a dictitem.
* This avoids adding a pointer to the hashtab item.
* DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
* HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
* HI2DI() converts a hashitem pointer to a dictitem pointer.
*/
static dictitem_T dumdi;
#define DI2HIKEY(di) ((di)->di_key)
#define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
#define HI2DI(hi) HIKEY2DI((hi)->hi_key)
/*
* Structure returned by get_lval() and used by set_var_lval().
* For a plain name:
@ -5352,7 +5340,7 @@ static int list_concat(list_T *l1, list_T *l2, typval_T *tv)
return FAIL;
/* make a copy of the first list. */
l = list_copy(l1, FALSE, 0);
l = list_copy(NULL, l1, FALSE, 0);
if (l == NULL)
return FAIL;
tv->v_type = VAR_LIST;
@ -5363,13 +5351,20 @@ static int list_concat(list_T *l1, list_T *l2, typval_T *tv)
return OK;
}
/*
* Make a copy of list "orig". Shallow if "deep" is FALSE.
* The refcount of the new list is set to 1.
* See item_copy() for "copyID".
* Returns NULL if orig is NULL or some failure happens.
*/
static list_T *list_copy(list_T *orig, int deep, int copyID)
/// Make a copy of list
///
/// @param[in] conv If non-NULL, then all internal strings will be converted.
/// @param[in] orig Original list to copy.
/// @param[in] deep If false, then shallow copy will be done.
/// @param[in] copyID See var_item_copy().
///
/// @return Copied list. May be NULL in case original list is NULL or some
/// failure happens. The refcount of the new list is set to 1.
static list_T *list_copy(const vimconv_T *const conv,
list_T *const orig,
const bool deep,
const int copyID)
FUNC_ATTR_WARN_UNUSED_RESULT
{
listitem_T *item;
listitem_T *ni;
@ -5388,7 +5383,7 @@ static list_T *list_copy(list_T *orig, int deep, int copyID)
item = item->li_next) {
ni = listitem_alloc();
if (deep) {
if (item_copy(&item->li_tv, &ni->li_tv, deep, copyID) == FAIL) {
if (var_item_copy(conv, &item->li_tv, &ni->li_tv, deep, copyID) == FAIL) {
xfree(ni);
break;
}
@ -5964,13 +5959,20 @@ void dictitem_free(dictitem_T *item)
xfree(item);
}
/*
* Make a copy of dict "d". Shallow if "deep" is FALSE.
* The refcount of the new dict is set to 1.
* See item_copy() for "copyID".
* Returns NULL if orig is NULL or some other failure.
*/
static dict_T *dict_copy(dict_T *orig, int deep, int copyID)
/// Make a copy of dictionary
///
/// @param[in] conv If non-NULL, then all internal strings will be converted.
/// @param[in] orig Original dictionary to copy.
/// @param[in] deep If false, then shallow copy will be done.
/// @param[in] copyID See var_item_copy().
///
/// @return 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.
static dict_T *dict_copy(const vimconv_T *const conv,
dict_T *const orig,
const bool deep,
const int copyID)
{
dictitem_T *di;
int todo;
@ -5990,10 +5992,21 @@ static dict_T *dict_copy(dict_T *orig, int deep, int copyID)
if (!HASHITEM_EMPTY(hi)) {
--todo;
di = dictitem_alloc(hi->hi_key);
if (conv == NULL || conv->vc_type == CONV_NONE) {
di = dictitem_alloc(hi->hi_key);
} else {
char *const key = (char *) string_convert((vimconv_T *) conv,
hi->hi_key, NULL);
if (key == NULL) {
di = dictitem_alloc(hi->hi_key);
} else {
di = dictitem_alloc((char_u *) key);
xfree(key);
}
}
if (deep) {
if (item_copy(&HI2DI(hi)->di_tv, &di->di_tv, deep,
copyID) == FAIL) {
if (var_item_copy(conv, &HI2DI(hi)->di_tv, &di->di_tv, deep,
copyID) == FAIL) {
xfree(di);
break;
}
@ -6305,7 +6318,7 @@ failret:
/// the results.
/// @param firstargname Name of the first argument.
/// @param name Name of the target converter.
#define DEFINE_VIML_CONV_FUNCTIONS(name, firstargtype, firstargname) \
#define DEFINE_VIML_CONV_FUNCTIONS(scope, name, firstargtype, firstargname) \
static int name##_convert_one_value(firstargtype firstargname, \
MPConvStack *const mpstack, \
typval_T *const tv, \
@ -6543,7 +6556,7 @@ name##_convert_one_value_regular_dict: \
return OK; \
} \
\
static int vim_to_##name(firstargtype firstargname, typval_T *const tv) \
scope int vim_to_##name(firstargtype firstargname, typval_T *const tv) \
FUNC_ATTR_WARN_UNUSED_RESULT \
{ \
current_copyID += COPYID_INC; \
@ -6739,7 +6752,7 @@ vim_to_msgpack_error_ret: \
#define CONV_ALLOW_SPECIAL false
DEFINE_VIML_CONV_FUNCTIONS(string, garray_T *const, gap)
DEFINE_VIML_CONV_FUNCTIONS(static, string, garray_T *const, gap)
#undef CONV_RECURSE
#define CONV_RECURSE(val, conv_type) \
@ -6769,7 +6782,7 @@ DEFINE_VIML_CONV_FUNCTIONS(string, garray_T *const, gap)
return OK; \
} while (0)
DEFINE_VIML_CONV_FUNCTIONS(echo, garray_T *const, gap)
DEFINE_VIML_CONV_FUNCTIONS(static, echo, garray_T *const, gap)
#undef CONV_STRING
#undef CONV_STR_STRING
@ -8344,7 +8357,7 @@ static void f_confirm(typval_T *argvars, typval_T *rettv)
*/
static void f_copy(typval_T *argvars, typval_T *rettv)
{
item_copy(&argvars[0], rettv, FALSE, 0);
var_item_copy(NULL, &argvars[0], rettv, false, 0);
}
/*
@ -8513,7 +8526,9 @@ static void f_deepcopy(typval_T *argvars, typval_T *rettv)
EMSG(_(e_invarg));
else {
current_copyID += COPYID_INC;
item_copy(&argvars[0], rettv, TRUE, noref == 0 ? current_copyID : 0);
var_item_copy(NULL, &argvars[0], rettv, true, (noref == 0
? current_copyID
: 0));
}
}
@ -12486,7 +12501,7 @@ static inline bool vim_list_to_buf(const list_T *const list,
#define CONV_ALLOW_SPECIAL true
DEFINE_VIML_CONV_FUNCTIONS(msgpack, msgpack_packer *const, packer)
DEFINE_VIML_CONV_FUNCTIONS(, msgpack, msgpack_packer *const, packer)
#undef CONV_STRING
#undef CONV_STR_STRING
@ -12592,7 +12607,7 @@ static inline ListReaderState init_lrstate(const list_T *const list)
}
/// Convert msgpack object to a VimL one
static int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
{
#define INIT_SPECIAL_DICT(tv, type, val) \
@ -18446,14 +18461,28 @@ void copy_tv(typval_T *from, typval_T *to)
}
}
/*
* Make a copy of an item.
* Lists and Dictionaries are also copied. A deep copy if "deep" is set.
* For deepcopy() "copyID" is zero for a full copy or the ID for when a
* reference to an already copied list/dict can be used.
* Returns FAIL or OK.
*/
static int item_copy(typval_T *from, typval_T *to, int deep, int copyID)
/// Make a copy of an item
///
/// Lists and Dictionaries are also copied.
///
/// @param[in] conv If not NULL, convert all copied strings.
/// @param[in] from Value to copy.
/// @param[out] to Location where to copy to.
/// @param[in] deep If true, use copy the container and all of the contained
/// containers (nested).
/// @param[in] copyID If non-zero then when container is referenced more then
/// once then copy of it that was already done is used. E.g.
/// when copying list `list = [list2, list2]` (`list[0] is
/// list[1]`) var_item_copy with zero copyID will emit
/// a copy with (`copy[0] isnot copy[1]`), with non-zero it
/// will emit a copy with (`copy[0] is copy[1]`) like in the
/// original list. Not use when deep is false.
int var_item_copy(const vimconv_T *const conv,
typval_T *const from,
typval_T *const to,
const bool deep,
const int copyID)
FUNC_ATTR_NONNULL_ARG(2,3)
{
static int recurse = 0;
int ret = OK;
@ -18467,10 +18496,23 @@ static int item_copy(typval_T *from, typval_T *to, int deep, int copyID)
switch (from->v_type) {
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_STRING:
case VAR_FUNC:
copy_tv(from, to);
break;
case VAR_STRING:
if (conv == NULL || conv->vc_type == CONV_NONE) {
copy_tv(from, to);
} else {
to->v_type = VAR_STRING;
to->v_lock = 0;
if ((to->vval.v_string = string_convert((vimconv_T *)conv,
from->vval.v_string,
NULL))
== NULL) {
to->vval.v_string = (char_u *) xstrdup((char *) from->vval.v_string);
}
}
break;
case VAR_LIST:
to->v_type = VAR_LIST;
to->v_lock = 0;
@ -18481,7 +18523,7 @@ static int item_copy(typval_T *from, typval_T *to, int deep, int copyID)
to->vval.v_list = from->vval.v_list->lv_copylist;
++to->vval.v_list->lv_refcount;
} else
to->vval.v_list = list_copy(from->vval.v_list, deep, copyID);
to->vval.v_list = list_copy(conv, from->vval.v_list, deep, copyID);
if (to->vval.v_list == NULL)
ret = FAIL;
break;
@ -18495,12 +18537,12 @@ static int item_copy(typval_T *from, typval_T *to, int deep, int copyID)
to->vval.v_dict = from->vval.v_dict->dv_copydict;
++to->vval.v_dict->dv_refcount;
} else
to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID);
to->vval.v_dict = dict_copy(conv, from->vval.v_dict, deep, copyID);
if (to->vval.v_dict == NULL)
ret = FAIL;
break;
default:
EMSG2(_(e_intern2), "item_copy()");
EMSG2(_(e_intern2), "var_item_copy()");
ret = FAIL;
}
--recurse;

4
src/nvim/eval.h
View File

@ -1,6 +1,8 @@
#ifndef NVIM_EVAL_H
#define NVIM_EVAL_H
#include <msgpack.h>
#include "nvim/profile.h"
/* Defines for Vim variables. These must match vimvars[] in eval.c! */
@ -72,6 +74,8 @@ enum {
/// Maximum number of function arguments
#define MAX_FUNC_ARGS 20
int vim_to_msgpack(msgpack_packer *const, typval_T *const);
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "eval.h.generated.h"
#endif

13
src/nvim/eval_defs.h
View File

@ -2,6 +2,7 @@
#define NVIM_EVAL_DEFS_H
#include <limits.h>
#include <stddef.h>
#include "nvim/hashtab.h"
@ -132,4 +133,16 @@ typedef struct list_stack_S {
struct list_stack_S *prev;
} list_stack_T;
// In a hashtab item "hi_key" points to "di_key" in a dictitem.
// This avoids adding a pointer to the hashtab item.
/// Convert a dictitem pointer to a hashitem key pointer
#define DI2HIKEY(di) ((di)->di_key)
/// Convert a hashitem key pointer to a dictitem pointer
#define HIKEY2DI(p) ((dictitem_T *)(p - offsetof(dictitem_T, di_key)))
/// Convert a hashitem pointer to a dictitem pointer
#define HI2DI(hi) HIKEY2DI((hi)->hi_key)
#endif // NVIM_EVAL_DEFS_H

7
src/nvim/ex_cmds.c
View File

@ -68,8 +68,6 @@
#include "nvim/os/shell.h"
#include "nvim/os/input.h"
#include "nvim/os/time.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
/*
* Struct to hold the sign properties.
@ -2846,10 +2844,7 @@ void sub_set_replacement(SubReplacementString sub)
{
xfree(old_sub.sub);
if (sub.additional_elements != old_sub.additional_elements) {
if (old_sub.additional_elements != NULL) {
api_free_array(*old_sub.additional_elements);
xfree(old_sub.additional_elements);
}
list_unref(old_sub.additional_elements);
}
old_sub = sub;
}

4
src/nvim/ex_cmds.h
View File

@ -4,7 +4,7 @@
#include <stdbool.h>
#include "nvim/os/time.h"
#include "nvim/api/private/defs.h"
#include "nvim/eval_defs.h"
/* flags for do_ecmd() */
#define ECMD_HIDE 0x01 /* don't free the current buffer */
@ -23,7 +23,7 @@
typedef struct {
char *sub; ///< Previous replacement string.
Timestamp timestamp; ///< Time when it was last set.
Array *additional_elements; ///< Additional data left from ShaDa file.
list_T *additional_elements; ///< Additional data left from ShaDa file.
} SubReplacementString;
#ifdef INCLUDE_GENERATED_DECLARATIONS

7
src/nvim/ex_getln.c
View File

@ -66,8 +66,6 @@
#include "nvim/os/os.h"
#include "nvim/event/loop.h"
#include "nvim/os/time.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
/*
* Variables shared between getcmdline(), redrawcmdline() and others.
@ -4252,10 +4250,7 @@ static inline void hist_free_entry(histentry_T *hisptr)
FUNC_ATTR_NONNULL_ALL
{
xfree(hisptr->hisstr);
if (hisptr->additional_elements != NULL) {
api_free_array(*hisptr->additional_elements);
xfree(hisptr->additional_elements);
}
list_unref(hisptr->additional_elements);
clear_hist_entry(hisptr);
}

3
src/nvim/ex_getln.h
View File

@ -1,6 +1,7 @@
#ifndef NVIM_EX_GETLN_H
#define NVIM_EX_GETLN_H
#include "nvim/eval_defs.h"
#include "nvim/ex_cmds.h"
/* Values for nextwild() and ExpandOne(). See ExpandOne() for meaning. */
@ -40,7 +41,7 @@ typedef struct hist_entry {
int hisnum; ///< Entry identifier number.
char_u *hisstr; ///< Actual entry, separator char after the NUL.
Timestamp timestamp; ///< Time when entry was added.
Array *additional_elements; ///< Additional entries from ShaDa file.
list_T *additional_elements; ///< Additional entries from ShaDa file.
} histentry_T;
#ifdef INCLUDE_GENERATED_DECLARATIONS

9
src/nvim/mark.c
View File

@ -41,8 +41,6 @@
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/os/input.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
/*
* This file contains routines to maintain and manipulate marks.
@ -74,11 +72,8 @@ int setmark(int c)
/// Free fmark_T item
void free_fmark(fmark_T fm)
{
if (fm.additional_data != NULL) {
api_free_dictionary(*fm.additional_data);
free(fm.additional_data);
fm.additional_data = NULL;
}
dict_unref(fm.additional_data);
fm.additional_data = NULL;
}
/// Free xfmark_T item

4
src/nvim/mark_defs.h
View File

@ -3,7 +3,7 @@
#include "nvim/pos.h"
#include "nvim/os/time.h"
#include "nvim/api/private/defs.h"
#include "nvim/eval_defs.h"
/*
* marks: positions in a file
@ -36,7 +36,7 @@ typedef struct filemark {
pos_T mark; ///< Cursor position.
int fnum; ///< File number.
Timestamp timestamp; ///< Time when this mark was last set.
Dictionary *additional_data; ///< Additional data from ShaDa file.
dict_T *additional_data; ///< Additional data from ShaDa file.
} fmark_T;
/// Structure defining extended mark (mark with file name attached)

10
src/nvim/ops.c
View File

@ -51,8 +51,6 @@
#include "nvim/window.h"
#include "nvim/os/input.h"
#include "nvim/os/time.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
static yankreg_T y_regs[NUM_REGISTERS];
@ -869,17 +867,13 @@ int do_record(int c)
return retval;
}
static void set_yreg_additional_data(yankreg_T *reg,
Dictionary *additional_data)
static void set_yreg_additional_data(yankreg_T *reg, dict_T *additional_data)
FUNC_ATTR_NONNULL_ARG(1)
{
if (reg->additional_data == additional_data) {
return;
}
if (reg->additional_data != NULL) {
api_free_dictionary(*reg->additional_data);
free(reg->additional_data);
}
dict_unref(reg->additional_data);
reg->additional_data = additional_data;
}

4
src/nvim/ops.h
View File

@ -6,7 +6,7 @@
#include "nvim/macros.h"
#include "nvim/ascii.h"
#include "nvim/types.h"
#include "nvim/api/private/defs.h"
#include "nvim/eval_defs.h"
#include "nvim/os/time.h"
typedef int (*Indenter)(void);
@ -81,7 +81,7 @@ typedef struct yankreg {
char_u y_type; ///< Register type: MLINE, MCHAR or MBLOCK.
colnr_T y_width; ///< Register width (only valid for y_type == MBLOCK).
Timestamp timestamp; ///< Time when register was last modified.
Dictionary *additional_data; ///< Additional data from ShaDa file.
dict_T *additional_data; ///< Additional data from ShaDa file.
} yankreg_T;
/// Convert register name into register index

6
src/nvim/search.c
View File

@ -51,7 +51,6 @@
#include "nvim/ui.h"
#include "nvim/window.h"
#include "nvim/os/time.h"
#include "nvim/api/private/helpers.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
@ -292,10 +291,7 @@ void restore_search_patterns(void)
static inline void free_spat(struct spat *const spat)
{
xfree(spat->pat);
if (spat->additional_data != NULL) {
api_free_dictionary(*spat->additional_data);
xfree(spat->additional_data);
}
dict_unref(spat->additional_data);
}
#if defined(EXITFREE)

2
src/nvim/search.h
View File

@ -60,7 +60,7 @@ typedef struct spat {
bool no_scs; ///< No smartcase for this pattern.
Timestamp timestamp; ///< Time of the last change.
SearchOffset off; ///< Pattern offset.
Dictionary *additional_data; ///< Additional data from ShaDa file.
dict_T *additional_data; ///< Additional data from ShaDa file.
} SearchPattern;
#ifdef INCLUDE_GENERATED_DECLARATIONS

528
src/nvim/shada.c
View File

@ -287,7 +287,7 @@ typedef struct {
char name;
pos_T mark;
char *fname;
Dictionary *additional_data;
dict_T *additional_data;
} filemark;
struct search_pattern {
bool magic;
@ -299,14 +299,13 @@ typedef struct {
bool is_substitute_pattern;
bool highlighted;
char *pat;
Dictionary *additional_data;
dict_T *additional_data;
} search_pattern;
struct history_item {
uint8_t histtype;
char *string;
char sep;
bool canfree;
Array *additional_elements;
list_T *additional_elements;
} history_item;
struct reg {
char name;
@ -314,12 +313,12 @@ typedef struct {
char **contents;
size_t contents_size;
size_t width;
Dictionary *additional_data;
dict_T *additional_data;
} reg;
struct global_var {
char *name;
Object value;
Array *additional_elements;
typval_T value;
list_T *additional_elements;
} global_var;
struct {
uint64_t type;
@ -328,14 +327,14 @@ typedef struct {
} unknown_item;
struct sub_string {
char *sub;
Array *additional_elements;
list_T *additional_elements;
} sub_string;
struct buffer_list {
size_t size;
struct buffer_list_buffer {
pos_T pos;
char *fname;
Dictionary *additional_data;
dict_T *additional_data;
} *buffers;
} buffer_list;
} data;
@ -899,7 +898,6 @@ static const void *shada_hist_iter(const void *const iter,
? (char) hist_he.hisstr[STRLEN(hist_he.hisstr) + 1]
: 0),
.additional_elements = hist_he.additional_elements,
.canfree = zero,
}
}
};
@ -1254,17 +1252,9 @@ static void shada_read(ShaDaReadDef *const sd_reader, const int flags)
break;
}
case kSDItemVariable: {
typval_T vartv;
Error err;
if (!object_to_vim(cur_entry.data.global_var.value, &vartv, &err)) {
if (err.set) {
emsg3(_(RERR "Error while reading ShaDa file: "
"failed to read value for variable %s: %s"),
cur_entry.data.global_var.name, err.msg);
}
break;
}
var_set_global(cur_entry.data.global_var.name, vartv);
var_set_global(cur_entry.data.global_var.name,
cur_entry.data.global_var.value);
cur_entry.data.global_var.value.v_type = VAR_UNKNOWN;
shada_free_shada_entry(&cur_entry);
break;
}
@ -1367,6 +1357,9 @@ static void shada_read(ShaDaReadDef *const sd_reader, const int flags)
cur_entry.data.buffer_list.buffers[i].pos, 0);
buflist_setfpos(buf, curwin, buf->b_last_cursor.mark.lnum,
buf->b_last_cursor.mark.col, false);
buf->additional_data =
cur_entry.data.buffer_list.buffers[i].additional_data;
cur_entry.data.buffer_list.buffers[i].additional_data = NULL;
}
}
shada_free_shada_entry(&cur_entry);
@ -1567,13 +1560,42 @@ static char *shada_filename(const char *file)
/// @param[in] max_kbyte Maximum size of an item in KiB. Zero means no
/// restrictions.
static bool shada_pack_entry(msgpack_packer *const packer,
const ShadaEntry entry,
ShadaEntry entry,
const size_t max_kbyte)
FUNC_ATTR_NONNULL_ALL
{
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer *spacker = msgpack_packer_new(&sbuf, &msgpack_sbuffer_write);
#define DUMP_ADDITIONAL_ELEMENTS(src) \
do { \
if ((src) != NULL) { \
for (listitem_T *li = (src)->lv_first; li != NULL; li = li->li_next) { \
if (vim_to_msgpack(spacker, &li->li_tv) == FAIL) { \
return false; \
} \
} \
} \
} while (0)
#define DUMP_ADDITIONAL_DATA(src) \
do { \
dict_T *const d = (src); \
if (d != NULL) { \
size_t todo = d->dv_hashtab.ht_used; \
for (const hashitem_T *hi= d->dv_hashtab.ht_array; todo; hi++) { \
if (!HASHITEM_EMPTY(hi)) { \
todo--; \
dictitem_T *const di = HI2DI(hi); \
const size_t key_len = strlen((const char *) hi->hi_key); \
msgpack_pack_str(spacker, key_len); \
msgpack_pack_str_body(spacker, (const char *) hi->hi_key, key_len); \
if (vim_to_msgpack(spacker, &di->di_tv) == FAIL) { \
return false; \
} \
} \
} \
} \
} while (0)
switch (entry.type) {
case kSDItemMissing: {
assert(false);
@ -1591,10 +1613,10 @@ static bool shada_pack_entry(msgpack_packer *const packer,
case kSDItemHistoryEntry: {
const bool is_hist_search =
entry.data.history_item.histtype == HIST_SEARCH;
const size_t arr_size = 2 + (size_t) is_hist_search + (
const size_t arr_size = 2 + (size_t) is_hist_search + (size_t) (
entry.data.history_item.additional_elements == NULL
? 0
: entry.data.history_item.additional_elements->size);
: entry.data.history_item.additional_elements->lv_len);
msgpack_pack_array(spacker, arr_size);
msgpack_pack_uint8(spacker, entry.data.history_item.histtype);
msgpack_rpc_from_string(cstr_as_string(entry.data.history_item.string),
@ -1602,39 +1624,32 @@ static bool shada_pack_entry(msgpack_packer *const packer,
if (is_hist_search) {
msgpack_pack_uint8(spacker, (uint8_t) entry.data.history_item.sep);
}
for (size_t i = 0; i < arr_size - 2 - (size_t) is_hist_search; i++) {
msgpack_rpc_from_object(
entry.data.history_item.additional_elements->items[i], spacker);
}
DUMP_ADDITIONAL_ELEMENTS(entry.data.history_item.additional_elements);
break;
}
case kSDItemVariable: {
const size_t arr_size = 2 + (
const size_t arr_size = 2 + (size_t) (
entry.data.global_var.additional_elements == NULL
? 0
: entry.data.global_var.additional_elements->size);
: entry.data.global_var.additional_elements->lv_len);
msgpack_pack_array(spacker, arr_size);
msgpack_rpc_from_string(cstr_as_string(entry.data.global_var.name),
spacker);
msgpack_rpc_from_object(entry.data.global_var.value, spacker);
for (size_t i = 0; i < arr_size - 2; i++) {
msgpack_rpc_from_object(
entry.data.global_var.additional_elements->items[i], spacker);
if (vim_to_msgpack(spacker, &entry.data.global_var.value) == FAIL) {
return false;
}
DUMP_ADDITIONAL_ELEMENTS(entry.data.global_var.additional_elements);
break;
}
case kSDItemSubString: {
const size_t arr_size = 1 + (
const size_t arr_size = 1 + (size_t) (
entry.data.sub_string.additional_elements == NULL
? 0
: entry.data.sub_string.additional_elements->size);
: entry.data.sub_string.additional_elements->lv_len);
msgpack_pack_array(spacker, arr_size);
msgpack_rpc_from_string(cstr_as_string(entry.data.sub_string.sub),
spacker);
for (size_t i = 0; i < arr_size - 1; i++) {
msgpack_rpc_from_object(
entry.data.sub_string.additional_elements->items[i], spacker);
}
DUMP_ADDITIONAL_ELEMENTS(entry.data.sub_string.additional_elements);
break;
}
case kSDItemSearchPattern: {
@ -1652,9 +1667,10 @@ static bool shada_pack_entry(msgpack_packer *const packer,
// offset defaults to zero:
+ (size_t) (entry.data.search_pattern.offset != 0)
// finally, additional data:
+ (size_t) (entry.data.search_pattern.additional_data
? entry.data.search_pattern.additional_data->size
: 0)
+ (size_t) (
entry.data.search_pattern.additional_data
? entry.data.search_pattern.additional_data->dv_hashtab.ht_used
: 0)
);
msgpack_pack_map(spacker, map_size);
PACK_STATIC_STR(SEARCH_KEY_PAT);
@ -1679,16 +1695,7 @@ static bool shada_pack_entry(msgpack_packer *const packer,
msgpack_pack_int64(spacker, entry.data.search_pattern.offset);
}
#undef PACK_BOOL
if (entry.data.search_pattern.additional_data != NULL) {
for (size_t i = 0; i < entry.data.search_pattern.additional_data->size;
i++) {
msgpack_rpc_from_string(
entry.data.search_pattern.additional_data->items[i].key, spacker);
msgpack_rpc_from_object(
entry.data.search_pattern.additional_data->items[i].value,
spacker);
}
}
DUMP_ADDITIONAL_DATA(entry.data.search_pattern.additional_data);
break;
}
case kSDItemChange:
@ -1706,9 +1713,10 @@ static bool shada_pack_entry(msgpack_packer *const packer,
&& entry.type != kSDItemChange
&& entry.data.filemark.name != '"')
// Additional entries, if any:
+ (size_t) (entry.data.filemark.additional_data == NULL
? 0
: entry.data.filemark.additional_data->size)
+ (size_t) (
entry.data.filemark.additional_data == NULL
? 0
: entry.data.filemark.additional_data->dv_hashtab.ht_used)
);
msgpack_pack_map(spacker, map_size);
PACK_STATIC_STR(KEY_FILE);
@ -1727,15 +1735,7 @@ static bool shada_pack_entry(msgpack_packer *const packer,
PACK_STATIC_STR(KEY_NAME_CHAR);
msgpack_pack_uint8(spacker, (uint8_t) entry.data.filemark.name);
}
if (entry.data.filemark.additional_data != NULL) {
for (size_t i = 0; i < entry.data.filemark.additional_data->size;
i++) {
msgpack_rpc_from_string(
entry.data.filemark.additional_data->items[i].key, spacker);
msgpack_rpc_from_object(
entry.data.filemark.additional_data->items[i].value, spacker);
}
}
DUMP_ADDITIONAL_DATA(entry.data.filemark.additional_data);
break;
}
case kSDItemRegister: {
@ -1748,7 +1748,7 @@ static bool shada_pack_entry(msgpack_packer *const packer,
// Additional entries, if any:
+ (size_t) (entry.data.reg.additional_data == NULL
? 0
: entry.data.reg.additional_data->size)
: entry.data.reg.additional_data->dv_hashtab.ht_used)
);
msgpack_pack_map(spacker, map_size);
PACK_STATIC_STR(REG_KEY_CONTENTS);
@ -1767,15 +1767,7 @@ static bool shada_pack_entry(msgpack_packer *const packer,
PACK_STATIC_STR(REG_KEY_WIDTH);
msgpack_pack_uint64(spacker, (uint64_t) entry.data.reg.width);
}
if (entry.data.reg.additional_data != NULL) {
for (size_t i = 0; i < entry.data.reg.additional_data->size;
i++) {
msgpack_rpc_from_string(entry.data.reg.additional_data->items[i].key,
spacker);
msgpack_rpc_from_object(
entry.data.reg.additional_data->items[i].value, spacker);
}
}
DUMP_ADDITIONAL_DATA(entry.data.reg.additional_data);
break;
}
case kSDItemBufferList: {
@ -1791,7 +1783,8 @@ static bool shada_pack_entry(msgpack_packer *const packer,
+ (size_t) (
entry.data.buffer_list.buffers[i].additional_data == NULL
? 0
: entry.data.buffer_list.buffers[i].additional_data->size)
: (entry.data.buffer_list.buffers[i].additional_data
->dv_hashtab.ht_used))
);
msgpack_pack_map(spacker, map_size);
PACK_STATIC_STR(KEY_FILE);
@ -1807,18 +1800,7 @@ static bool shada_pack_entry(msgpack_packer *const packer,
msgpack_pack_uint64(
spacker, (uint64_t) entry.data.buffer_list.buffers[i].pos.col);
}
if (entry.data.buffer_list.buffers[i].additional_data != NULL) {
for (size_t j = 0;
j < entry.data.buffer_list.buffers[i].additional_data->size;
j++) {
msgpack_rpc_from_string(
entry.data.buffer_list.buffers[i].additional_data->items[j].key,
spacker);
msgpack_rpc_from_object(
entry.data.buffer_list.buffers[i].additional_data->items[j].value,
spacker);
}
}
DUMP_ADDITIONAL_DATA(entry.data.buffer_list.buffers[i].additional_data);
}
break;
}
@ -1917,7 +1899,11 @@ static bool shada_pack_encoded_entry(msgpack_packer *const packer,
}
case kSDItemVariable: {
if (sd_conv->vc_type != CONV_NONE) {
convert_object(sd_conv, &entry.data.data.global_var.value);
typval_T tgttv;
var_item_copy(sd_conv, &entry.data.data.global_var.value, &tgttv,
true, 0);
clear_tv(&entry.data.data.global_var.value);
entry.data.data.global_var.value = tgttv;
}
ret = shada_pack_entry(packer, entry.data, max_kbyte);
break;
@ -2135,9 +2121,11 @@ static ShaDaWriteResult shada_write(ShaDaWriteDef *const sd_writer,
if (var_iter == NULL && vartv.v_type == VAR_UNKNOWN) {
break;
}
Object obj = vim_to_object(&vartv);
typval_T tgttv;
if (sd_writer->sd_conv.vc_type != CONV_NONE) {
convert_object(&sd_writer->sd_conv, &obj);
var_item_copy(&sd_writer->sd_conv, &vartv, &tgttv, true, 0);
} else {
copy_tv(&vartv, &tgttv);
}
if (!shada_pack_entry(packer, (ShadaEntry) {
.type = kSDItemVariable,
@ -2145,18 +2133,18 @@ static ShaDaWriteResult shada_write(ShaDaWriteDef *const sd_writer,
.data = {
.global_var = {
.name = (char *) name,
.value = obj,
.value = tgttv,
.additional_elements = NULL,
}
}
}, max_kbyte)) {
api_free_object(obj);
clear_tv(&vartv);
clear_tv(&tgttv);
ret = kSDWriteFailed;
goto shada_write_exit;
}
api_free_object(obj);
clear_tv(&vartv);
clear_tv(&tgttv);
int kh_ret;
(void) kh_put(strset, &wms->dumped_variables, name, &kh_ret);
} while (var_iter != NULL);
@ -2970,26 +2958,17 @@ static void shada_free_shada_entry(ShadaEntry *const entry)
case kSDItemJump:
case kSDItemGlobalMark:
case kSDItemLocalMark: {
if (entry->data.filemark.additional_data != NULL) {
api_free_dictionary(*entry->data.filemark.additional_data);
xfree(entry->data.filemark.additional_data);
}
dict_unref(entry->data.filemark.additional_data);
xfree(entry->data.filemark.fname);
break;
}
case kSDItemSearchPattern: {
if (entry->data.search_pattern.additional_data != NULL) {
api_free_dictionary(*entry->data.search_pattern.additional_data);
xfree(entry->data.search_pattern.additional_data);
}
dict_unref(entry->data.search_pattern.additional_data);
xfree(entry->data.search_pattern.pat);
break;
}
case kSDItemRegister: {
if (entry->data.reg.additional_data != NULL) {
api_free_dictionary(*entry->data.reg.additional_data);
xfree(entry->data.reg.additional_data);
}
dict_unref(entry->data.reg.additional_data);
for (size_t i = 0; i < entry->data.reg.contents_size; i++) {
xfree(entry->data.reg.contents[i]);
}
@ -2997,40 +2976,25 @@ static void shada_free_shada_entry(ShadaEntry *const entry)
break;
}
case kSDItemHistoryEntry: {
if (entry->data.history_item.canfree) {
if (entry->data.history_item.additional_elements != NULL) {
api_free_array(*entry->data.history_item.additional_elements);
xfree(entry->data.history_item.additional_elements);
}
xfree(entry->data.history_item.string);
}
list_unref(entry->data.history_item.additional_elements);
xfree(entry->data.history_item.string);
break;
}
case kSDItemVariable: {
if (entry->data.global_var.additional_elements != NULL) {
api_free_array(*entry->data.global_var.additional_elements);
xfree(entry->data.global_var.additional_elements);
}
list_unref(entry->data.global_var.additional_elements);
xfree(entry->data.global_var.name);
api_free_object(entry->data.global_var.value);
clear_tv(&entry->data.global_var.value);
break;
}
case kSDItemSubString: {
if (entry->data.sub_string.additional_elements != NULL) {
api_free_array(*entry->data.sub_string.additional_elements);
xfree(entry->data.sub_string.additional_elements);
}
list_unref(entry->data.sub_string.additional_elements);
xfree(entry->data.sub_string.sub);
break;
}
case kSDItemBufferList: {
for (size_t i = 0; i < entry->data.buffer_list.size; i++) {
xfree(entry->data.buffer_list.buffers[i].fname);
if (entry->data.buffer_list.buffers[i].additional_data != NULL) {
api_free_dictionary(
*entry->data.buffer_list.buffers[i].additional_data);
xfree(entry->data.buffer_list.buffers[i].additional_data);
}
dict_unref(entry->data.buffer_list.buffers[i].additional_data);
}
xfree(entry->data.buffer_list.buffers);
break;
@ -3177,77 +3141,6 @@ static ShaDaReadResult msgpack_read_uint64(ShaDaReadDef *const sd_reader,
return kSDReadStatusSuccess;
}
/// Convert all strings in one Object instance
///
/// @param[in] sd_conv Conversion definition.
/// @param[in,out] obj Object to convert.
static void convert_object(const vimconv_T *const sd_conv, Object *const obj)
FUNC_ATTR_NONNULL_ALL
{
kvec_t(Object *) toconv;
kv_init(toconv);
kv_push(Object *, toconv, obj);
while (kv_size(toconv)) {
Object *cur_obj = kv_pop(toconv);
#define CONVERT_STRING(str) \
do { \
if (!has_non_ascii((str).data)) { \
break; \
} \
size_t len = (str).size; \
char *const converted_string = string_convert(sd_conv, (str).data, \
&len); \
if (converted_string != NULL) { \
xfree((str).data); \
(str).data = converted_string; \
(str).size = len; \
} \
} while (0)
switch (cur_obj->type) {
case kObjectTypeNil:
case kObjectTypeInteger:
case kObjectTypeBoolean:
case kObjectTypeFloat: {
break;
}
case kObjectTypeString: {
CONVERT_STRING(cur_obj->data.string);
break;
}
case kObjectTypeArray: {
for (size_t i = 0; i < cur_obj->data.array.size; i++) {
Object *element = &cur_obj->data.array.items[i];
if (element->type == kObjectTypeDictionary
|| element->type == kObjectTypeArray) {
kv_push(Object *, toconv, element);
} else if (element->type == kObjectTypeString) {
CONVERT_STRING(element->data.string);
}
}
break;
}
case kObjectTypeDictionary: {
for (size_t i = 0; i < cur_obj->data.dictionary.size; i++) {
CONVERT_STRING(cur_obj->data.dictionary.items[i].key);
Object *value = &cur_obj->data.dictionary.items[i].value;
if (value->type == kObjectTypeDictionary
|| value->type == kObjectTypeArray) {
kv_push(Object *, toconv, value);
} else if (value->type == kObjectTypeString) {
CONVERT_STRING(value->data.string);
}
}
break;
}
default: {
assert(false);
}
}
#undef CONVERT_STRING
}
kv_destroy(toconv);
}
/// Convert or copy and return a string
///
/// @param[in] sd_conv Conversion definition.
@ -3490,6 +3383,58 @@ shada_read_next_item_extra_bytes:
? get_converted_string(&sd_reader->sd_conv, (str), (len)) \
: xmemdupz((str), (len)))
#define BIN_CONVERTED(b) CONVERTED(b.ptr, b.size)
#define SET_ADDITIONAL_DATA(tgt, name) \
do { \
if (ad_ga.ga_len) { \
msgpack_object obj = { \
.type = MSGPACK_OBJECT_MAP, \
.via = { \
.map = { \
.size = (uint32_t) ad_ga.ga_len, \
.ptr = ad_ga.ga_data, \
} \
} \
}; \
typval_T adtv; \
if (msgpack_to_vim(obj, &adtv) == FAIL \
|| adtv.v_type != VAR_DICT) { \
emsgu(_(RERR "Error while reading ShaDa file: " \
name " entry at position %" PRIu64 " " \
"cannot be converted to a VimL dictionary"), \
(uint64_t) initial_fpos); \
ga_clear(&ad_ga); \
clear_tv(&adtv); \
goto shada_read_next_item_error; \
} \
tgt = adtv.vval.v_dict; \
} \
ga_clear(&ad_ga); \
} while (0)
#define SET_ADDITIONAL_ELEMENTS(src, src_maxsize, tgt, name) \
do { \
if ((src).size > (size_t) (src_maxsize)) { \
msgpack_object obj = { \
.type = MSGPACK_OBJECT_ARRAY, \
.via = { \
.array = { \
.size = ((src).size - (uint32_t) (src_maxsize)), \
.ptr = (src).ptr + (src_maxsize), \
} \
} \
}; \
typval_T aetv; \
if (msgpack_to_vim(obj, &aetv) == FAIL) { \
emsgu(_(RERR "Error while reading ShaDa file: " \
name " entry at position %" PRIu64 " " \
"cannot be converted to a VimL list"), \
(uint64_t) initial_fpos); \
clear_tv(&aetv); \
goto shada_read_next_item_error; \
} \
assert(aetv.v_type == VAR_LIST); \
(tgt) = aetv.vval.v_list; \
} \
} while (0)
switch ((ShadaEntryType) type_u64) {
case kSDItemHeader: {
if (!msgpack_rpc_to_dictionary(&(unpacked.data), &(entry->data.header))) {
@ -3552,29 +3497,8 @@ shada_read_next_item_extra_bytes:
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
if (ad_ga.ga_len) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_MAP,
.via = {
.map = {
.size = (uint32_t) ad_ga.ga_len,
.ptr = ad_ga.ga_data,
}
}
};
entry->data.search_pattern.additional_data =
xmalloc(sizeof(Dictionary));
if (!msgpack_rpc_to_dictionary(
&obj, entry->data.search_pattern.additional_data)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"search pattern entry at position %" PRIu64 " "
"cannot be converted to a Dictionary"),
(uint64_t) initial_fpos);
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
}
ga_clear(&ad_ga);
SET_ADDITIONAL_DATA(entry->data.search_pattern.additional_data,
"search pattern");
break;
}
case kSDItemChange:
@ -3643,28 +3567,7 @@ shada_read_next_item_extra_bytes:
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
if (ad_ga.ga_len) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_MAP,
.via = {
.map = {
.size = (uint32_t) ad_ga.ga_len,
.ptr = ad_ga.ga_data,
}
}
};
entry->data.filemark.additional_data = xmalloc(sizeof(Dictionary));
if (!msgpack_rpc_to_dictionary(
&obj, entry->data.filemark.additional_data)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"mark entry at position %" PRIu64 " "
"cannot be converted to a Dictionary"),
(uint64_t) initial_fpos);
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
}
ga_clear(&ad_ga);
SET_ADDITIONAL_DATA(entry->data.filemark.additional_data, "mark");
break;
}
case kSDItemRegister: {
@ -3738,28 +3641,7 @@ shada_read_next_item_extra_bytes:
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
if (ad_ga.ga_len) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_MAP,
.via = {
.map = {
.size = (uint32_t) ad_ga.ga_len,
.ptr = ad_ga.ga_data,
}
}
};
entry->data.reg.additional_data = xmalloc(sizeof(Dictionary));
if (!msgpack_rpc_to_dictionary(
&obj, entry->data.reg.additional_data)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"register entry at position %" PRIu64 " "
"cannot be converted to a Dictionary"),
(uint64_t) initial_fpos);
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
}
ga_clear(&ad_ga);
SET_ADDITIONAL_DATA(entry->data.reg.additional_data, "register");
break;
}
case kSDItemHistoryEntry: {
@ -3859,27 +3741,9 @@ shada_read_next_item_hist_no_conv:
entry->data.history_item.string[strsize - 2] = 0;
entry->data.history_item.string[strsize - 1] =
entry->data.history_item.sep;
if (unpacked.data.via.array.size > (size_t) (2 + is_hist_search)) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_ARRAY,
.via = {
.array = {
.size = (unpacked.data.via.array.size
- (uint32_t) (2 + is_hist_search)),
.ptr = unpacked.data.via.array.ptr + (2 + is_hist_search),
}
}
};
entry->data.history_item.additional_elements = xmalloc(sizeof(Array));
if (!msgpack_rpc_to_array(
&obj, entry->data.history_item.additional_elements)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"history entry at position %" PRIu64 " "
"cannot be converted to an Array"),
(uint64_t) initial_fpos);
goto shada_read_next_item_error;
}
}
SET_ADDITIONAL_ELEMENTS(unpacked.data.via.array, (2 + is_hist_search),
entry->data.history_item.additional_elements,
"history");
break;
}
case kSDItemVariable: {
@ -3893,7 +3757,7 @@ shada_read_next_item_hist_no_conv:
entry->data.global_var = (struct global_var) {
.name = NULL,
.value = {
.type = kObjectTypeNil,
.v_type = VAR_UNKNOWN,
},
.additional_elements = NULL
};
@ -3922,37 +3786,27 @@ shada_read_next_item_hist_no_conv:
entry->data.global_var.name =
xmemdupz(unpacked.data.via.array.ptr[0].via.bin.ptr,
unpacked.data.via.array.ptr[0].via.bin.size);
if (!msgpack_rpc_to_object(&(unpacked.data.via.array.ptr[1]),
&(entry->data.global_var.value))) {
if (msgpack_to_vim(unpacked.data.via.array.ptr[1],
&(entry->data.global_var.value)) == FAIL) {
emsgu(_(RERR "Error while reading ShaDa file: "
"variable entry at position %" PRIu64 " "
"has value that cannot be converted to the object"),
"has value that cannot be converted to the VimL value"),
(uint64_t) initial_fpos);
goto shada_read_next_item_error;
}
if (sd_reader->sd_conv.vc_type != CONV_NONE) {
convert_object(&sd_reader->sd_conv, &entry->data.global_var.value);
}
if (unpacked.data.via.array.size > 2) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_ARRAY,
.via = {
.array = {
.size = unpacked.data.via.array.size - 2,
.ptr = unpacked.data.via.array.ptr + 2,
}
}
};
entry->data.global_var.additional_elements = xmalloc(sizeof(Array));
if (!msgpack_rpc_to_array(
&obj, entry->data.global_var.additional_elements)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"variable entry at position %" PRIu64 " "
"cannot be converted to an Array"),
(uint64_t) initial_fpos);
goto shada_read_next_item_error;
}
typval_T tgttv;
var_item_copy(&sd_reader->sd_conv,
&entry->data.global_var.value,
&tgttv,
true,
0);
clear_tv(&entry->data.global_var.value);
entry->data.global_var.value = tgttv;
}
SET_ADDITIONAL_ELEMENTS(unpacked.data.via.array, 2,
entry->data.global_var.additional_elements,
"variable");
break;
}
case kSDItemSubString: {
@ -3983,26 +3837,9 @@ shada_read_next_item_hist_no_conv:
}
entry->data.sub_string.sub =
BIN_CONVERTED(unpacked.data.via.array.ptr[0].via.bin);
if (unpacked.data.via.array.size > 1) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_ARRAY,
.via = {
.array = {
.size = unpacked.data.via.array.size - 1,
.ptr = unpacked.data.via.array.ptr + 1,
}
}
};
entry->data.sub_string.additional_elements = xmalloc(sizeof(Array));
if (!msgpack_rpc_to_array(
&obj, entry->data.sub_string.additional_elements)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"sub string entry at position %" PRIu64 " "
"cannot be converted to an Array"),
(uint64_t) initial_fpos);
goto shada_read_next_item_error;
}
}
SET_ADDITIONAL_ELEMENTS(unpacked.data.via.array, 1,
entry->data.sub_string.additional_elements,
"sub string");
break;
}
case kSDItemBufferList: {
@ -4079,30 +3916,9 @@ shada_read_next_item_hist_no_conv:
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
if (ad_ga.ga_len) {
msgpack_object obj = {
.type = MSGPACK_OBJECT_MAP,
.via = {
.map = {
.size = (uint32_t) ad_ga.ga_len,
.ptr = ad_ga.ga_data,
}
}
};
entry->data.buffer_list.buffers[i].additional_data =
xmalloc(sizeof(Dictionary));
if (!msgpack_rpc_to_dictionary(
&obj, entry->data.buffer_list.buffers[i].additional_data)) {
emsgu(_(RERR "Error while reading ShaDa file: "
"buffer list at position %" PRIu64 " "
"contains entry that cannot be converted "
"to a Dictionary"),
(uint64_t) initial_fpos);
ga_clear(&ad_ga);
goto shada_read_next_item_error;
}
}
ga_clear(&ad_ga);
SET_ADDITIONAL_DATA(
entry->data.buffer_list.buffers[i].additional_data,
"buffer list entry");
}
}
break;
@ -4132,6 +3948,8 @@ shada_read_next_item_hist_no_conv:
#undef LONG_KEY
#undef TOU8
#undef TOSIZE
#undef SET_ADDITIONAL_DATA
#undef SET_ADDITIONAL_ELEMENTS
shada_read_next_item_error:
msgpack_unpacked_destroy(&unpacked);
xfree(buf);

8
src/nvim/undo.c
View File

@ -111,7 +111,6 @@
#include "nvim/types.h"
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/api/private/helpers.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "undo.c.generated.h"
@ -329,11 +328,8 @@ static long get_undolevel(void)
static inline void zero_fmark_additional_data(fmark_T *fmarks)
{
for (size_t i = 0; i < NMARKS; i++) {
if (fmarks[i].additional_data != NULL) {
api_free_dictionary(*fmarks[i].additional_data);
free(fmarks[i].additional_data);
fmarks[i].additional_data = NULL;
}
dict_unref(fmarks[i].additional_data);
fmarks[i].additional_data = NULL;
}
}