mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 22:18:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #29467 from bfredl/shadapack2

Browse Source 
refactor(shada): don't use msgpack_packer for shada
This commit is contained in:
bfredl
2024-06-29 11:57:37 +02:00
committed by GitHub
parent c33f670da2 782b3024ef
commit ace0d5306b
3 changed files with 82 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/nvim/eval/encode.c
View File

@@ -918,7 +918,7 @@ char *encode_tv2json(typval_T *tv, size_t *len)
} }
#define TYPVAL_ENCODE_CONV_STRING(tv, buf, len) \ #define TYPVAL_ENCODE_CONV_STRING(tv, buf, len) \
mpack_bin(buf, (len), packer); \ mpack_bin(cbuf_as_string(buf, (len)), packer); \
#define TYPVAL_ENCODE_CONV_STR_STRING(tv, buf, len) \ #define TYPVAL_ENCODE_CONV_STR_STRING(tv, buf, len) \
mpack_str(cbuf_as_string(buf, (len)), packer); \ mpack_str(cbuf_as_string(buf, (len)), packer); \
@@ -927,7 +927,7 @@ char *encode_tv2json(typval_T *tv, size_t *len)
mpack_ext(buf, (len), (int8_t)(type), packer); \ mpack_ext(buf, (len), (int8_t)(type), packer); \
#define TYPVAL_ENCODE_CONV_BLOB(tv, blob, len) \ #define TYPVAL_ENCODE_CONV_BLOB(tv, blob, len) \
mpack_bin((blob) ? (blob)->bv_ga.ga_data : NULL, (size_t)(len), packer); \ mpack_bin(cbuf_as_string((blob) ? (blob)->bv_ga.ga_data : NULL, (size_t)(len)), packer);
#define TYPVAL_ENCODE_CONV_NUMBER(tv, num) \ #define TYPVAL_ENCODE_CONV_NUMBER(tv, num) \
mpack_integer(&packer->ptr, (Integer)(num)) mpack_integer(&packer->ptr, (Integer)(num))

8
src/nvim/msgpack_rpc/packer.c
View File

@@ -10,7 +10,7 @@
void mpack_check_buffer(PackerBuffer *packer) void mpack_check_buffer(PackerBuffer *packer)
{ {
if (mpack_remaining(packer) < MPACK_ITEM_SIZE) { if (mpack_remaining(packer) < 2 * MPACK_ITEM_SIZE) {
packer->packer_flush(packer); packer->packer_flush(packer);
} }
} }
@@ -87,8 +87,9 @@ void mpack_str(String str, PackerBuffer *packer)
mpack_raw(str.data, len, packer); mpack_raw(str.data, len, packer);
} }
void mpack_bin(const char *data, size_t len, PackerBuffer *packer) void mpack_bin(String str, PackerBuffer *packer)
{ {
const size_t len = str.size;
if (len < 0xff) { if (len < 0xff) {
mpack_w(&packer->ptr, 0xc4); mpack_w(&packer->ptr, 0xc4);
mpack_w(&packer->ptr, len); mpack_w(&packer->ptr, len);
@@ -102,7 +103,7 @@ void mpack_bin(const char *data, size_t len, PackerBuffer *packer)
abort(); abort();
} }
mpack_raw(data, len, packer); mpack_raw(str.data, len, packer);
} }
void mpack_raw(const char *data, size_t len, PackerBuffer *packer) void mpack_raw(const char *data, size_t len, PackerBuffer *packer)
@@ -119,6 +120,7 @@ void mpack_raw(const char *data, size_t len, PackerBuffer *packer)
packer->packer_flush(packer); packer->packer_flush(packer);
} }
} }
mpack_check_buffer(packer);
} }
void mpack_ext(char *buf, size_t len, int8_t type, PackerBuffer *packer) void mpack_ext(char *buf, size_t len, int8_t type, PackerBuffer *packer)

188
src/nvim/shada.c
View File

@@ -1338,26 +1338,15 @@ static char *shada_filename(const char *file)
return xstrdup(file); return xstrdup(file);
} }
#define PACK_STATIC_STR(s) \ #define PACK_STATIC_STR(s) mpack_str(STATIC_CSTR_AS_STRING(s), &sbuf);
do { \
msgpack_pack_str(spacker, sizeof(s) - 1); \
msgpack_pack_str_body(spacker, s, sizeof(s) - 1); \
} while (0)
#define PACK_BIN(s) \
do { \
const String s_ = (s); \
msgpack_pack_bin(spacker, s_.size); \
if (s_.size > 0) { \
msgpack_pack_bin_body(spacker, s_.data, s_.size); \
} \
} while (0)
#define SHADA_MPACK_FREE_SPACE (4 * MPACK_ITEM_SIZE) #define SHADA_MPACK_FREE_SPACE (4 * MPACK_ITEM_SIZE)
static int mpack_raw_wrapper(void *cookie, const char *data, size_t len) static void shada_check_buffer(PackerBuffer *packer)
{ {
mpack_raw(data, len, (PackerBuffer *)cookie); if (mpack_remaining(packer) < SHADA_MPACK_FREE_SPACE) {
return 0; packer->packer_flush(packer);
}
} }
/// Write single ShaDa entry /// Write single ShaDa entry
@@ -1374,7 +1363,6 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
{ {
ShaDaWriteResult ret = kSDWriteFailed; ShaDaWriteResult ret = kSDWriteFailed;
PackerBuffer sbuf = packer_string_buffer(); PackerBuffer sbuf = packer_string_buffer();
msgpack_packer *spacker = msgpack_packer_new(&sbuf, &mpack_raw_wrapper);
#define DUMP_ADDITIONAL_ELEMENTS(src, what) \ #define DUMP_ADDITIONAL_ELEMENTS(src, what) \
do { \ do { \
if ((src) != NULL) { \ if ((src) != NULL) { \
@@ -1396,9 +1384,7 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
if (!HASHITEM_EMPTY(hi)) { \ if (!HASHITEM_EMPTY(hi)) { \
todo--; \ todo--; \
dictitem_T *const di = TV_DICT_HI2DI(hi); \ dictitem_T *const di = TV_DICT_HI2DI(hi); \
const size_t key_len = strlen(hi->hi_key); \ mpack_str(cstr_as_string(hi->hi_key), &sbuf); \
msgpack_pack_str(spacker, key_len); \
msgpack_pack_str_body(spacker, hi->hi_key, key_len); \
if (encode_vim_to_msgpack(&sbuf, &di->di_tv, \ if (encode_vim_to_msgpack(&sbuf, &di->di_tv, \
_("additional data of ShaDa " what)) \ _("additional data of ShaDa " what)) \
== FAIL) { \ == FAIL) { \
@@ -1411,40 +1397,33 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
#define CHECK_DEFAULT(entry, attr) \ #define CHECK_DEFAULT(entry, attr) \
(sd_default_values[(entry).type].data.attr == (entry).data.attr) (sd_default_values[(entry).type].data.attr == (entry).data.attr)
#define ONE_IF_NOT_DEFAULT(entry, attr) \ #define ONE_IF_NOT_DEFAULT(entry, attr) \
((size_t)(!CHECK_DEFAULT(entry, attr))) ((uint32_t)(!CHECK_DEFAULT(entry, attr)))
#define PACK_BOOL(entry, name, attr) \ #define PACK_BOOL(entry, name, attr) \
do { \ do { \
if (!CHECK_DEFAULT(entry, search_pattern.attr)) { \ if (!CHECK_DEFAULT(entry, search_pattern.attr)) { \
PACK_STATIC_STR(name); \ PACK_STATIC_STR(name); \
if (sd_default_values[(entry).type].data.search_pattern.attr) { \ mpack_bool(&sbuf.ptr, !sd_default_values[(entry).type].data.search_pattern.attr); \
msgpack_pack_false(spacker); \
} else { \
msgpack_pack_true(spacker); \
} \
} \ } \
} while (0) } while (0)
shada_check_buffer(&sbuf);
switch (entry.type) { switch (entry.type) {
case kSDItemMissing: case kSDItemMissing:
abort(); abort();
case kSDItemUnknown: case kSDItemUnknown:
if (spacker->callback(spacker->data, entry.data.unknown_item.contents, mpack_raw(entry.data.unknown_item.contents, entry.data.unknown_item.size, &sbuf);
(unsigned)entry.data.unknown_item.size) == -1) {
goto shada_pack_entry_error;
}
break; break;
case kSDItemHistoryEntry: { case kSDItemHistoryEntry: {
const bool is_hist_search = const bool is_hist_search =
entry.data.history_item.histtype == HIST_SEARCH; entry.data.history_item.histtype == HIST_SEARCH;
const size_t arr_size = 2 + (size_t)is_hist_search + (size_t)( uint32_t arr_size = (2 + (uint32_t)is_hist_search
tv_list_len(entry.data. + (uint32_t)(tv_list_len(entry.data.history_item.additional_elements)));
history_item. mpack_array(&sbuf.ptr, arr_size);
additional_elements)); mpack_uint(&sbuf.ptr, entry.data.history_item.histtype);
msgpack_pack_array(spacker, arr_size); mpack_bin(cstr_as_string(entry.data.history_item.string), &sbuf);
msgpack_pack_uint8(spacker, entry.data.history_item.histtype);
PACK_BIN(cstr_as_string(entry.data.history_item.string));
if (is_hist_search) { if (is_hist_search) {
msgpack_pack_uint8(spacker, (uint8_t)entry.data.history_item.sep); mpack_uint(&sbuf.ptr, (uint8_t)entry.data.history_item.sep);
} }
DUMP_ADDITIONAL_ELEMENTS(entry.data.history_item.additional_elements, DUMP_ADDITIONAL_ELEMENTS(entry.data.history_item.additional_elements,
"history entry item"); "history entry item");
@@ -1458,10 +1437,10 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
tv_list_append_number(list, VAR_TYPE_BLOB); tv_list_append_number(list, VAR_TYPE_BLOB);
entry.data.global_var.additional_elements = list; entry.data.global_var.additional_elements = list;
} }
const size_t arr_size = 2 + (size_t)(tv_list_len(entry.data.global_var.additional_elements)); uint32_t arr_size = 2 + (uint32_t)(tv_list_len(entry.data.global_var.additional_elements));
msgpack_pack_array(spacker, arr_size); mpack_array(&sbuf.ptr, arr_size);
const String varname = cstr_as_string(entry.data.global_var.name); const String varname = cstr_as_string(entry.data.global_var.name);
PACK_BIN(varname); mpack_bin(varname, &sbuf);
char vardesc[256] = "variable g:"; char vardesc[256] = "variable g:";
memcpy(&vardesc[sizeof("variable g:") - 1], varname.data, memcpy(&vardesc[sizeof("variable g:") - 1], varname.data,
varname.size + 1); varname.size + 1);
@@ -1477,35 +1456,33 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
break; break;
} }
case kSDItemSubString: { case kSDItemSubString: {
const size_t arr_size = 1 + (size_t)( uint32_t arr_size = 1 + (uint32_t)(tv_list_len(entry.data.sub_string.additional_elements));
tv_list_len(entry.data.sub_string.additional_elements)); mpack_array(&sbuf.ptr, arr_size);
msgpack_pack_array(spacker, arr_size); mpack_bin(cstr_as_string(entry.data.sub_string.sub), &sbuf);
PACK_BIN(cstr_as_string(entry.data.sub_string.sub));
DUMP_ADDITIONAL_ELEMENTS(entry.data.sub_string.additional_elements, DUMP_ADDITIONAL_ELEMENTS(entry.data.sub_string.additional_elements,
"sub string item"); "sub string item");
break; break;
} }
case kSDItemSearchPattern: { case kSDItemSearchPattern: {
size_t entry_map_size = ( uint32_t entry_map_size = (1 // Search pattern is always present
1 // Search pattern is always present + ONE_IF_NOT_DEFAULT(entry, search_pattern.magic)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.magic) + ONE_IF_NOT_DEFAULT(entry, search_pattern.is_last_used)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.is_last_used) + ONE_IF_NOT_DEFAULT(entry, search_pattern.smartcase)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.smartcase) + ONE_IF_NOT_DEFAULT(entry, search_pattern.has_line_offset)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.has_line_offset) + ONE_IF_NOT_DEFAULT(entry, search_pattern.place_cursor_at_end)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.place_cursor_at_end) + ONE_IF_NOT_DEFAULT(entry,
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.is_substitute_pattern)
search_pattern.is_substitute_pattern) + ONE_IF_NOT_DEFAULT(entry, search_pattern.highlighted)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.highlighted) + ONE_IF_NOT_DEFAULT(entry, search_pattern.offset)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.offset) + ONE_IF_NOT_DEFAULT(entry, search_pattern.search_backward)
+ ONE_IF_NOT_DEFAULT(entry, search_pattern.search_backward) // finally, additional data:
// finally, additional data: + (entry.data.search_pattern.additional_data
+ ( ? (uint32_t)entry.data.search_pattern.additional_data->dv_hashtab.
entry.data.search_pattern.additional_data ht_used
? entry.data.search_pattern.additional_data->dv_hashtab.ht_used : 0));
: 0)); mpack_map(&sbuf.ptr, entry_map_size);
msgpack_pack_map(spacker, entry_map_size);
PACK_STATIC_STR(SEARCH_KEY_PAT); PACK_STATIC_STR(SEARCH_KEY_PAT);
PACK_BIN(cstr_as_string(entry.data.search_pattern.pat)); mpack_bin(cstr_as_string(entry.data.search_pattern.pat), &sbuf);
PACK_BOOL(entry, SEARCH_KEY_MAGIC, magic); PACK_BOOL(entry, SEARCH_KEY_MAGIC, magic);
PACK_BOOL(entry, SEARCH_KEY_IS_LAST_USED, is_last_used); PACK_BOOL(entry, SEARCH_KEY_IS_LAST_USED, is_last_used);
PACK_BOOL(entry, SEARCH_KEY_SMARTCASE, smartcase); PACK_BOOL(entry, SEARCH_KEY_SMARTCASE, smartcase);
@@ -1516,7 +1493,7 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
PACK_BOOL(entry, SEARCH_KEY_BACKWARD, search_backward); PACK_BOOL(entry, SEARCH_KEY_BACKWARD, search_backward);
if (!CHECK_DEFAULT(entry, search_pattern.offset)) { if (!CHECK_DEFAULT(entry, search_pattern.offset)) {
PACK_STATIC_STR(SEARCH_KEY_OFFSET); PACK_STATIC_STR(SEARCH_KEY_OFFSET);
msgpack_pack_int64(spacker, entry.data.search_pattern.offset); mpack_integer(&sbuf.ptr, entry.data.search_pattern.offset);
} }
#undef PACK_BOOL #undef PACK_BOOL
DUMP_ADDITIONAL_DATA(entry.data.search_pattern.additional_data, DUMP_ADDITIONAL_DATA(entry.data.search_pattern.additional_data,
@@ -1527,8 +1504,7 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
case kSDItemGlobalMark: case kSDItemGlobalMark:
case kSDItemLocalMark: case kSDItemLocalMark:
case kSDItemJump: { case kSDItemJump: {
size_t entry_map_size = ( size_t entry_map_size = (1 // File name
1 // File name
+ ONE_IF_NOT_DEFAULT(entry, filemark.mark.lnum) + ONE_IF_NOT_DEFAULT(entry, filemark.mark.lnum)
+ ONE_IF_NOT_DEFAULT(entry, filemark.mark.col) + ONE_IF_NOT_DEFAULT(entry, filemark.mark.col)
+ ONE_IF_NOT_DEFAULT(entry, filemark.name) + ONE_IF_NOT_DEFAULT(entry, filemark.name)
@@ -1537,110 +1513,99 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
entry.data.filemark.additional_data == NULL entry.data.filemark.additional_data == NULL
? 0 ? 0
: entry.data.filemark.additional_data->dv_hashtab.ht_used)); : entry.data.filemark.additional_data->dv_hashtab.ht_used));
msgpack_pack_map(spacker, entry_map_size); mpack_map(&sbuf.ptr, (uint32_t)entry_map_size);
PACK_STATIC_STR(KEY_FILE); PACK_STATIC_STR(KEY_FILE);
PACK_BIN(cstr_as_string(entry.data.filemark.fname)); mpack_bin(cstr_as_string(entry.data.filemark.fname), &sbuf);
if (!CHECK_DEFAULT(entry, filemark.mark.lnum)) { if (!CHECK_DEFAULT(entry, filemark.mark.lnum)) {
PACK_STATIC_STR(KEY_LNUM); PACK_STATIC_STR(KEY_LNUM);
msgpack_pack_long(spacker, entry.data.filemark.mark.lnum); mpack_integer(&sbuf.ptr, entry.data.filemark.mark.lnum);
} }
if (!CHECK_DEFAULT(entry, filemark.mark.col)) { if (!CHECK_DEFAULT(entry, filemark.mark.col)) {
PACK_STATIC_STR(KEY_COL); PACK_STATIC_STR(KEY_COL);
msgpack_pack_long(spacker, entry.data.filemark.mark.col); mpack_integer(&sbuf.ptr, entry.data.filemark.mark.col);
} }
assert(entry.type == kSDItemJump || entry.type == kSDItemChange assert(entry.type == kSDItemJump || entry.type == kSDItemChange
? CHECK_DEFAULT(entry, filemark.name) ? CHECK_DEFAULT(entry, filemark.name)
: true); : true);
if (!CHECK_DEFAULT(entry, filemark.name)) { if (!CHECK_DEFAULT(entry, filemark.name)) {
PACK_STATIC_STR(KEY_NAME_CHAR); PACK_STATIC_STR(KEY_NAME_CHAR);
msgpack_pack_uint8(spacker, (uint8_t)entry.data.filemark.name); mpack_uint(&sbuf.ptr, (uint8_t)entry.data.filemark.name);
} }
DUMP_ADDITIONAL_DATA(entry.data.filemark.additional_data, DUMP_ADDITIONAL_DATA(entry.data.filemark.additional_data,
"mark (change, jump, global or local) item"); "mark (change, jump, global or local) item");
break; break;
} }
case kSDItemRegister: { case kSDItemRegister: {
size_t entry_map_size = (2 // Register contents and name uint32_t entry_map_size = (2 // Register contents and name
+ ONE_IF_NOT_DEFAULT(entry, reg.type) + ONE_IF_NOT_DEFAULT(entry, reg.type)
+ ONE_IF_NOT_DEFAULT(entry, reg.width) + ONE_IF_NOT_DEFAULT(entry, reg.width)
+ ONE_IF_NOT_DEFAULT(entry, reg.is_unnamed) + ONE_IF_NOT_DEFAULT(entry, reg.is_unnamed)
// Additional entries, if any: // Additional entries, if any:
+ (entry.data.reg.additional_data == NULL + (entry.data.reg.additional_data == NULL
? 0 ? 0
: entry.data.reg.additional_data->dv_hashtab.ht_used)); : (uint32_t)entry.data.reg.additional_data->dv_hashtab.ht_used));
msgpack_pack_map(spacker, entry_map_size); mpack_map(&sbuf.ptr, entry_map_size);
PACK_STATIC_STR(REG_KEY_CONTENTS); PACK_STATIC_STR(REG_KEY_CONTENTS);
msgpack_pack_array(spacker, entry.data.reg.contents_size); mpack_array(&sbuf.ptr, (uint32_t)entry.data.reg.contents_size);
for (size_t i = 0; i < entry.data.reg.contents_size; i++) { for (size_t i = 0; i < entry.data.reg.contents_size; i++) {
PACK_BIN(cstr_as_string(entry.data.reg.contents[i])); mpack_bin(cstr_as_string(entry.data.reg.contents[i]), &sbuf);
} }
PACK_STATIC_STR(KEY_NAME_CHAR); PACK_STATIC_STR(KEY_NAME_CHAR);
msgpack_pack_char(spacker, entry.data.reg.name); mpack_uint(&sbuf.ptr, (uint8_t)entry.data.reg.name);
if (!CHECK_DEFAULT(entry, reg.type)) { if (!CHECK_DEFAULT(entry, reg.type)) {
PACK_STATIC_STR(REG_KEY_TYPE); PACK_STATIC_STR(REG_KEY_TYPE);
msgpack_pack_uint8(spacker, (uint8_t)entry.data.reg.type); mpack_uint(&sbuf.ptr, (uint8_t)entry.data.reg.type);
} }
if (!CHECK_DEFAULT(entry, reg.width)) { if (!CHECK_DEFAULT(entry, reg.width)) {
PACK_STATIC_STR(REG_KEY_WIDTH); PACK_STATIC_STR(REG_KEY_WIDTH);
msgpack_pack_uint64(spacker, (uint64_t)entry.data.reg.width); mpack_uint64(&sbuf.ptr, (uint64_t)entry.data.reg.width);
} }
if (!CHECK_DEFAULT(entry, reg.is_unnamed)) { if (!CHECK_DEFAULT(entry, reg.is_unnamed)) {
PACK_STATIC_STR(REG_KEY_UNNAMED); PACK_STATIC_STR(REG_KEY_UNNAMED);
if (entry.data.reg.is_unnamed) { mpack_bool(&sbuf.ptr, entry.data.reg.is_unnamed);
msgpack_pack_true(spacker);
} else {
msgpack_pack_false(spacker);
}
} }
DUMP_ADDITIONAL_DATA(entry.data.reg.additional_data, "register item"); DUMP_ADDITIONAL_DATA(entry.data.reg.additional_data, "register item");
break; break;
} }
case kSDItemBufferList: case kSDItemBufferList:
msgpack_pack_array(spacker, entry.data.buffer_list.size); mpack_array(&sbuf.ptr, (uint32_t)entry.data.buffer_list.size);
for (size_t i = 0; i < entry.data.buffer_list.size; i++) { for (size_t i = 0; i < entry.data.buffer_list.size; i++) {
size_t entry_map_size = ( size_t entry_map_size = (1 // Buffer name
1 // Buffer name
+ (size_t)(entry.data.buffer_list.buffers[i].pos.lnum + (size_t)(entry.data.buffer_list.buffers[i].pos.lnum
!= default_pos.lnum) != default_pos.lnum)
+ (size_t)(entry.data.buffer_list.buffers[i].pos.col + (size_t)(entry.data.buffer_list.buffers[i].pos.col
!= default_pos.col) != default_pos.col)
// Additional entries, if any: // Additional entries, if any:
+ ( + (entry.data.buffer_list.buffers[i].additional_data == NULL
entry.data.buffer_list.buffers[i].additional_data
== NULL
? 0 ? 0
: (entry.data.buffer_list.buffers[i].additional_data : (entry.data.buffer_list.buffers[i].additional_data
->dv_hashtab.ht_used))); ->dv_hashtab.ht_used)));
msgpack_pack_map(spacker, entry_map_size); mpack_map(&sbuf.ptr, (uint32_t)entry_map_size);
PACK_STATIC_STR(KEY_FILE); PACK_STATIC_STR(KEY_FILE);
PACK_BIN(cstr_as_string(entry.data.buffer_list.buffers[i].fname)); mpack_bin(cstr_as_string(entry.data.buffer_list.buffers[i].fname), &sbuf);
if (entry.data.buffer_list.buffers[i].pos.lnum != 1) { if (entry.data.buffer_list.buffers[i].pos.lnum != 1) {
PACK_STATIC_STR(KEY_LNUM); PACK_STATIC_STR(KEY_LNUM);
msgpack_pack_uint64(spacker, (uint64_t)entry.data.buffer_list.buffers[i].pos.lnum); mpack_uint64(&sbuf.ptr, (uint64_t)entry.data.buffer_list.buffers[i].pos.lnum);
} }
if (entry.data.buffer_list.buffers[i].pos.col != 0) { if (entry.data.buffer_list.buffers[i].pos.col != 0) {
PACK_STATIC_STR(KEY_COL); PACK_STATIC_STR(KEY_COL);
msgpack_pack_uint64(spacker, (uint64_t)entry.data.buffer_list.buffers[i].pos.col); mpack_uint64(&sbuf.ptr, (uint64_t)entry.data.buffer_list.buffers[i].pos.col);
} }
DUMP_ADDITIONAL_DATA(entry.data.buffer_list.buffers[i].additional_data, DUMP_ADDITIONAL_DATA(entry.data.buffer_list.buffers[i].additional_data,
"buffer list subitem"); "buffer list subitem");
} }
break; break;
case kSDItemHeader: case kSDItemHeader:
msgpack_pack_map(spacker, entry.data.header.size); mpack_map(&sbuf.ptr, (uint32_t)entry.data.header.size);
for (size_t i = 0; i < entry.data.header.size; i++) { for (size_t i = 0; i < entry.data.header.size; i++) {
const String s = entry.data.header.items[i].key; mpack_str(entry.data.header.items[i].key, &sbuf);
msgpack_pack_str(spacker, s.size);
if (s.size) {
msgpack_pack_str_body(spacker, s.data, s.size);
}
const Object obj = entry.data.header.items[i].value; const Object obj = entry.data.header.items[i].value;
switch (obj.type) { switch (obj.type) {
case kObjectTypeString: case kObjectTypeString:
PACK_BIN(obj.data.string); mpack_bin(obj.data.string, &sbuf);
break; break;
case kObjectTypeInteger: case kObjectTypeInteger:
msgpack_pack_int64(spacker, (int64_t)obj.data.integer); mpack_integer(&sbuf.ptr, obj.data.integer);
break; break;
default: default:
abort(); abort();
@@ -1652,9 +1617,7 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
#undef ONE_IF_NOT_DEFAULT #undef ONE_IF_NOT_DEFAULT
String packed = packer_take_string(&sbuf); String packed = packer_take_string(&sbuf);
if (!max_kbyte || packed.size <= max_kbyte * 1024) { if (!max_kbyte || packed.size <= max_kbyte * 1024) {
if (mpack_remaining(packer) < SHADA_MPACK_FREE_SPACE) { shada_check_buffer(packer);
packer->packer_flush(packer);
}
if (entry.type == kSDItemUnknown) { if (entry.type == kSDItemUnknown) {
mpack_uint64(&packer->ptr, entry.data.unknown_item.type); mpack_uint64(&packer->ptr, entry.data.unknown_item.type);
@@ -1673,7 +1636,6 @@ static ShaDaWriteResult shada_pack_entry(PackerBuffer *const packer, ShadaEntry
} }
ret = kSDWriteSuccessful; ret = kSDWriteSuccessful;
shada_pack_entry_error: shada_pack_entry_error:
msgpack_packer_free(spacker);
xfree(sbuf.startptr); xfree(sbuf.startptr);
return ret; return ret;
} }