Skip to content

Instantly share code, notes, and snippets.

@erw7

erw7/typval.c

Created May 28, 2020 11:21
Show Gist options
  • Save erw7/08d219b51ee475e3fa20a71dd313330d to your computer and use it in GitHub Desktop.
Save erw7/08d219b51ee475e3fa20a71dd313330d to your computer and use it in GitHub Desktop.
Download ZIP
Raw
typval.c
static int encode_vim_to_nothing(
const void *const ignored,
typval_T *const tv, const char *const objname)
__attribute__((nonnull(2, 3))) __attribute__((warn_unused_result));
static int encode_vim_to_nothing(
const void *const ignored,
typval_T *const top_tv, const char *const objname)
{
const int copyID = get_copyID();
MPConvStack mpstack;
((mpstack).capacity = ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0]))))), (mpstack).size = 0, (mpstack).items = (mpstack).init_array);
if (_typval_encode_nothing_convert_one_value(ignored, &mpstack, ((void *)0), top_tv, copyID, objname) == 0) {
goto encode_vim_to__error_ret;
}
typval_encode_stop_converting_one_item:
while (((mpstack).size)) {
MPConvStackVal *cur_mpsv = &((mpstack).items[(((mpstack).size) - (0) - 1)]);
typval_T *tv = ((void *)0);
switch (cur_mpsv->type) {
case kMPConvDict: {
if (!cur_mpsv->data.d.todo) {
(void)((mpstack).items[--(mpstack).size]);
cur_mpsv->data.d.dict->dv_copyID = cur_mpsv->saved_copyID;
_nothing_conv_dict_end(cur_mpsv->tv, (dict_T **)&*cur_mpsv->data.d.dictp, (void *)&_typval_encode_nothing_nodict_var);
continue;
} else if (cur_mpsv->data.d.todo != cur_mpsv->data.d.dict->dv_hashtab.ht_used) {
;
}
while (((cur_mpsv->data.d.hi)->hi_key == ((void *)0)
|| (cur_mpsv->data.d.hi)->hi_key == (char_u *)&hash_removed)) {
cur_mpsv->data.d.hi++;
}
dictitem_T *const di =
((dictitem_T *)((cur_mpsv->data.d.hi)->hi_key - __builtin_offsetof (dictitem_T, di_key)));
cur_mpsv->data.d.todo--;
cur_mpsv->data.d.hi++;
tv = &di->di_tv;
break;
}
case kMPConvList: {
if (cur_mpsv->data.l.li == ((void *)0)) {
(void)((mpstack).items[--(mpstack).size]);
tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
_nothing_conv_list_end(cur_mpsv->tv);
continue;
} else if (cur_mpsv->data.l.li != tv_list_first(cur_mpsv->data.l.list)) {
;
}
tv = (&(cur_mpsv->data.l.li)->li_tv);
cur_mpsv->data.l.li = ((cur_mpsv->data.l.li)->li_next);
break;
}
case kMPConvPairs: {
if (cur_mpsv->data.l.li == ((void *)0)) {
(void)((mpstack).items[--(mpstack).size]);
tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
_nothing_conv_dict_end(cur_mpsv->tv, (dict_T **)&_typval_encode_nothing_nodict_var, (void *)&_typval_encode_nothing_nodict_var);
continue;
} else if (cur_mpsv->data.l.li != tv_list_first(cur_mpsv->data.l.list)) {
;
}
const list_T *const kv_pair = ((&(cur_mpsv->data.l.li)->li_tv)->vval.v_list);
if (_typval_encode_nothing_convert_one_value(ignored, &mpstack, cur_mpsv, (&(tv_list_first(kv_pair))->li_tv), copyID, objname) == 0) {
goto encode_vim_to__error_ret;
}
tv = (&(tv_list_last(kv_pair))->li_tv);
cur_mpsv->data.l.li = ((cur_mpsv->data.l.li)->li_next);
break;
}
case kMPConvPartial: {
partial_T *const pt = cur_mpsv->data.p.pt;
tv = cur_mpsv->tv;
(void)tv;
switch (cur_mpsv->data.p.stage) {
case kMPConvPartialArgs: {
cur_mpsv->data.p.stage = kMPConvPartialSelf;
if (pt != ((void *)0) && pt->pt_argc > 0) {
;
(*((((mpstack).size == (mpstack).capacity) ? (((mpstack).capacity = (((mpstack).capacity << 1) > ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0]))))) ? ((mpstack).capacity << 1) : ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0])))))), (mpstack).items = ((mpstack).capacity == ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0]))))) ? ((mpstack).items == (mpstack).init_array ? (mpstack).items : _memcpy_free((mpstack).init_array, (mpstack).items, (mpstack).size * sizeof((mpstack).items[0]))) : ((mpstack).items == (mpstack).init_array ? memcpy(xmalloc((mpstack).capacity * sizeof((mpstack).items[0])), (mpstack).items, (mpstack).size * sizeof((mpstack).items[0])) : xrealloc((mpstack).items, (mpstack).capacity * sizeof((mpstack).items[0]))))), 0) : 0), ((mpstack).items + ((mpstack).size++))) = (((MPConvStackVal) {
.type = kMPConvPartialList, .tv = ((void *)0),
.saved_copyID = copyID - 1,
.data = {
.a = {
.arg = pt->pt_argv,
.argv = pt->pt_argv,
.todo = (size_t)pt->pt_argc,
},
},
})));
}
break;
}
case kMPConvPartialSelf: {
cur_mpsv->data.p.stage = kMPConvPartialEnd;
dict_T *const dict = pt == ((void *)0) ? ((void *)0) : pt->pt_dict;
if (dict != ((void *)0)) {
if (dict->dv_hashtab.ht_used == 0) {
do {
(void) ((!!((void *)&pt->pt_dict != (void *)&_typval_encode_nothing_nodict_var))
|| (_assert("(void *)&pt->pt_dict != (void *)&TYPVAL_ENCODE_NODICT_VAR",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",773),0));
_nothing_conv_empty_dict(((void *)0), ((dict_T **)&pt->pt_dict));
} while (0);
continue;
}
const int saved_copyID = dict->dv_copyID;
const int te_csr_ret = _typval_encode_nothing_check_self_reference(ignored, dict, &dict->dv_copyID, &mpstack, copyID, kMPConvDict, objname);
if (te_csr_ret != 2) {
if (te_csr_ret == 0) {
goto encode_vim_to__error_ret;
} else {
continue;
}
}
(void) ((!!(saved_copyID != copyID && saved_copyID != copyID - 1))
|| (_assert("saved_copyID != copyID && saved_copyID != copyID - 1",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",790),0));
(*((((mpstack).size == (mpstack).capacity) ? (((mpstack).capacity = (((mpstack).capacity << 1) > ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0]))))) ? ((mpstack).capacity << 1) : ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0])))))), (mpstack).items = ((mpstack).capacity == ((sizeof((mpstack).init_array)/sizeof(((mpstack).init_array)[0])) / ((size_t)(!(sizeof((mpstack).init_array) % sizeof(((mpstack).init_array)[0]))))) ? ((mpstack).items == (mpstack).init_array ? (mpstack).items : _memcpy_free((mpstack).init_array, (mpstack).items, (mpstack).size * sizeof((mpstack).items[0]))) : ((mpstack).items == (mpstack).init_array ? memcpy(xmalloc((mpstack).capacity * sizeof((mpstack).items[0])), (mpstack).items, (mpstack).size * sizeof((mpstack).items[0])) : xrealloc((mpstack).items, (mpstack).capacity * sizeof((mpstack).items[0]))))), 0) : 0), ((mpstack).items + ((mpstack).size++))) = (((MPConvStackVal) {
.type = kMPConvDict,
.tv = ((void *)0),
.saved_copyID = saved_copyID,
.data = {
.d = {
.dict = dict,
.dictp = &pt->pt_dict,
.hi = dict->dv_hashtab.ht_array,
.todo = dict->dv_hashtab.ht_used,
},
},
})));
do {
if (_nothing_conv_real_dict_after_start(((void *)0) , (dict_T **)&pt->pt_dict, (void *)&_typval_encode_nothing_nodict_var, &((mpstack).items[(((mpstack).size) - (0) - 1)])) != 2) {
goto typval_encode_stop_converting_one_item;
}
} while (0);
} else {
;
}
break;
}
case kMPConvPartialEnd: {
_nothing_conv_func_end(tv, copyID);
(void)((mpstack).items[--(mpstack).size]);
break;
}
}
continue;
}
case kMPConvPartialList: {
if (!cur_mpsv->data.a.todo) {
(void)((mpstack).items[--(mpstack).size]);
_nothing_conv_list_end( ((void *)0));
continue;
} else if (cur_mpsv->data.a.argv != cur_mpsv->data.a.arg) {
;
}
tv = cur_mpsv->data.a.arg++;
cur_mpsv->data.a.todo--;
break;
}
}
(void) ((!!(tv != ((void *)0)))
|| (_assert("tv != NULL",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",832),0));
if (_typval_encode_nothing_convert_one_value(ignored, &mpstack, cur_mpsv, tv, copyID, objname) == 0) {
goto encode_vim_to__error_ret;
}
}
do {
if ((mpstack).items != (mpstack).init_array) {
do {
void **ptr_ = (void **)&((mpstack).items);
xfree(*ptr_);
*ptr_ = ((void *)0);
(void)(*ptr_);
} while (0);
}
} while (0);
return 1;
encode_vim_to__error_ret:
do {
if ((mpstack).items != (mpstack).init_array) {
do {
void **ptr_ = (void **)&((mpstack).items); xfree(*ptr_);
*ptr_ = ((void *)0);
(void)(*ptr_);
} while (0);
}
} while (0);
return 0;
goto typval_encode_stop_converting_one_item;
}
static int _typval_encode_nothing_convert_one_value(
const void *const ignored,
MPConvStack *const mpstack, MPConvStackVal *const cur_mpsv,
typval_T *const tv, const int copyID,
const char *const objname)
__attribute__((nonnull(2, 4, 6))) __attribute__((warn_unused_result));
static int _typval_encode_nothing_convert_one_value(
const void *const ignored,
MPConvStack *const mpstack, MPConvStackVal *const cur_mpsv,
typval_T *const tv, const int copyID,
const char *const objname)
{
switch (tv->v_type) {
case VAR_STRING: {
do { xfree(tv->vval.v_string);
tv->vval.v_string = ((void *)0);
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case VAR_NUMBER: {
do {
(void)tv->vval.v_number;
tv->vval.v_number = 0;
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case VAR_FLOAT: {
do {
tv->vval.v_float = 0;
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case VAR_FUNC: {
do {
if (_nothing_conv_func_start(tv, tv->vval.v_string) != 2) {
return 1;
}
} while (0);
_nothing_conv_func_end(tv, copyID);
break;
}
case VAR_PARTIAL: {
partial_T *const pt = tv->vval.v_partial;
(void)pt;
do {
if (_nothing_conv_func_start(tv, (pt == ((void *)0) ? ((void *)0) : partial_name(pt))) != 2) {
return 1;
}
} while (0)
;
(*((((*mpstack).size == (*mpstack).capacity) ? (((*mpstack).capacity = (((*mpstack).capacity << 1) > ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).capacity << 1) : ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0])))))), (*mpstack).items = ((*mpstack).capacity == ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).items == (*mpstack).init_array ? (*mpstack).items : _memcpy_free((*mpstack).init_array, (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0]))) : ((*mpstack).items == (*mpstack).init_array ? memcpy(xmalloc((*mpstack).capacity * sizeof((*mpstack).items[0])), (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0])) : xrealloc((*mpstack).items, (*mpstack).capacity * sizeof((*mpstack).items[0]))))), 0) : 0), ((*mpstack).items + ((*mpstack).size++))) = (((MPConvStackVal) { .type = kMPConvPartial, .tv = tv, .saved_copyID = copyID - 1, .data = { .p = { .stage = kMPConvPartialArgs, .pt = tv->vval.v_partial, }, }, })));
break;
}
case VAR_LIST: {
if (tv->vval.v_list == ((void *)0) || tv_list_len(tv->vval.v_list) == 0) {
do {
tv_list_unref(tv->vval.v_list);
tv->vval.v_list = ((void *)0);
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
const int saved_copyID = tv_list_copyid(tv->vval.v_list);
do {
const int te_csr_ret = _typval_encode_nothing_check_self_reference( ignored, (tv->vval.v_list), &(tv->vval.v_list)->lv_copyID, mpstack, copyID, kMPConvList, objname);
if (te_csr_ret != 2) {
return te_csr_ret;
}
} while (0);
(void) ((!!(saved_copyID != copyID && saved_copyID != copyID - 1))
|| (_assert("saved_copyID != copyID && saved_copyID != copyID - 1",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",367),0));
(*((((*mpstack).size == (*mpstack).capacity) ? (((*mpstack).capacity = (((*mpstack).capacity << 1) > ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).capacity << 1) : ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0])))))), (*mpstack).items = ((*mpstack).capacity == ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).items == (*mpstack).init_array ? (*mpstack).items : _memcpy_free((*mpstack).init_array, (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0]))) : ((*mpstack).items == (*mpstack).init_array ? memcpy(xmalloc((*mpstack).capacity * sizeof((*mpstack).items[0])), (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0])) : xrealloc((*mpstack).items, (*mpstack).capacity * sizeof((*mpstack).items[0]))))), 0) : 0), ((*mpstack).items + ((*mpstack).size++))) = (((MPConvStackVal) { .type = kMPConvList, .tv = tv, .saved_copyID = saved_copyID, .data = { .l = { .list = tv->vval.v_list, .li = tv_list_first(tv->vval.v_list), }, }, })));
do {
if (_nothing_conv_real_list_after_start(tv, &((*mpstack).items[(((*mpstack).size) - (0) - 1)])) != 2) {
goto typval_encode_stop_converting_one_item;
}
} while (0);
break;
}
case VAR_SPECIAL: {
switch (tv->vval.v_special) {
case kSpecialVarNull: {
do { tv->vval.v_special = kSpecialVarFalse; tv->v_lock = VAR_UNLOCKED; } while (0);
break;
}
case kSpecialVarTrue:
case kSpecialVarFalse: {
do { tv->vval.v_special = kSpecialVarFalse; tv->v_lock = VAR_UNLOCKED; } while (0);
break;
}
}
break;
}
case VAR_DICT: {
if (tv->vval.v_dict == ((void *)0)
|| tv->vval.v_dict->dv_hashtab.ht_used == 0) {
do {
(void) ((!!((void *)&tv->vval.v_dict != (void *)&_typval_encode_nothing_nodict_var))
|| (_assert("(void *)&tv->vval.v_dict != (void *)&TYPVAL_ENCODE_NODICT_VAR",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",399),0));
_nothing_conv_empty_dict(tv, ((dict_T **)&tv->vval.v_dict));
} while (0);
break;
}
const dictitem_T *type_di;
const dictitem_T *val_di;
if (0 && tv->vval.v_dict->dv_hashtab.ht_used == 2
&& (type_di = tv_dict_find((dict_T *)tv->vval.v_dict, ("_TYPE"), (sizeof("_TYPE") - 1))) != ((void *)0)
&& type_di->di_tv.v_type == VAR_LIST
&& (val_di = tv_dict_find((dict_T *)tv->vval.v_dict, ("_VAL"), (sizeof("_VAL") - 1))) != ((void *)0)) {
size_t i;
for (i = 0; i < ((sizeof(eval_msgpack_type_lists)/sizeof((eval_msgpack_type_lists)[0])) / ((size_t)(!(sizeof(eval_msgpack_type_lists) % sizeof((eval_msgpack_type_lists)[0]))))); i++) {
if (type_di->di_tv.vval.v_list == eval_msgpack_type_lists[i]) {
break;
}
}
if (i == ((sizeof(eval_msgpack_type_lists)/sizeof((eval_msgpack_type_lists)[0])) / ((size_t)(!(sizeof(eval_msgpack_type_lists) % sizeof((eval_msgpack_type_lists)[0])))))) {
goto _convert_one_value_regular_dict;
}
switch ((MessagePackType)i) {
case kMPNil: {
do {
tv->vval.v_special = kSpecialVarFalse;
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case kMPBoolean: {
if (val_di->di_tv.v_type != VAR_NUMBER) {
goto _convert_one_value_regular_dict;
}
do {
tv->vval.v_special = kSpecialVarFalse;
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case kMPInteger: {
const list_T *val_list;
varnumber_T sign;
varnumber_T highest_bits;
varnumber_T high_bits;
varnumber_T low_bits;
if (val_di->di_tv.v_type != VAR_LIST
|| tv_list_len(val_list = val_di->di_tv.vval.v_list) != 4) {
goto _convert_one_value_regular_dict;
}
const listitem_T *const sign_li = tv_list_first(val_list);
if ((&(sign_li)->li_tv)->v_type != VAR_NUMBER
|| (sign = (&(sign_li)->li_tv)->vval.v_number) == 0) {
goto _convert_one_value_regular_dict;
}
const listitem_T *const highest_bits_li = (
((sign_li)->li_next));
if ((&(highest_bits_li)->li_tv)->v_type != VAR_NUMBER
|| ((highest_bits
= (&(highest_bits_li)->li_tv)->vval.v_number) < 0)) {
goto _convert_one_value_regular_dict;
}
const listitem_T *const high_bits_li = (
((highest_bits_li)->li_next));
if ((&(high_bits_li)->li_tv)->v_type != VAR_NUMBER
|| ((high_bits = (&(high_bits_li)->li_tv)->vval.v_number) < 0)) {
goto _convert_one_value_regular_dict;
}
const listitem_T *const low_bits_li = tv_list_last(val_list);
if ((&(low_bits_li)->li_tv)->v_type != VAR_NUMBER
|| ((low_bits = (&(low_bits_li)->li_tv)->vval.v_number) < 0)) {
goto _convert_one_value_regular_dict;
}
const uint64_t number = ((uint64_t)(((uint64_t)highest_bits) << 62)
| (uint64_t)(((uint64_t)high_bits) << 31)
| (uint64_t)low_bits);
if (sign > 0) {
;
} else {
do {
(void)-number;
tv->vval.v_number = 0;
tv->v_lock = VAR_UNLOCKED;
} while (0);
}
break;
}
case kMPFloat: {
if (val_di->di_tv.v_type != VAR_FLOAT) {
goto _convert_one_value_regular_dict;
}
do {
tv->vval.v_float = 0;
tv->v_lock = VAR_UNLOCKED;
} while (0);
break;
}
case kMPString:
case kMPBinary: {
const _Bool is_string = ((MessagePackType)i == kMPString);
if (val_di->di_tv.v_type != VAR_LIST) {
goto _convert_one_value_regular_dict;
}
size_t len;
char *buf;
if (!encode_vim_list_to_buf(val_di->di_tv.vval.v_list, &len, &buf)) {
goto _convert_one_value_regular_dict;
}
if (is_string) {
;
} else {
do {
xfree(buf);
tv->vval.v_string = ((void *)0);
tv->v_lock = VAR_UNLOCKED;
} while (0);
}
xfree(buf);
break;
}
case kMPArray: {
if (val_di->di_tv.v_type != VAR_LIST) {
goto _convert_one_value_regular_dict;
}
const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
do {
const int te_csr_ret =
_typval_encode_nothing_check_self_reference( ignored, (val_di->di_tv.vval.v_list), &(val_di->di_tv.vval.v_list)->lv_copyID, mpstack, copyID, kMPConvList, objname);
if (te_csr_ret != 2) {
return te_csr_ret;
}
} while (0);
(void) ((!!(saved_copyID != copyID && saved_copyID != copyID - 1))
|| (_assert("saved_copyID != copyID && saved_copyID != copyID - 1",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",525),0));
(*((((*mpstack).size == (*mpstack).capacity) ? (((*mpstack).capacity = (((*mpstack).capacity << 1) > ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).capacity << 1) : ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0])))))), (*mpstack).items = ((*mpstack).capacity == ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).items == (*mpstack).init_array ? (*mpstack).items : _memcpy_free((*mpstack).init_array, (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0]))) : ((*mpstack).items == (*mpstack).init_array ? memcpy(xmalloc((*mpstack).capacity * sizeof((*mpstack).items[0])), (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0])) : xrealloc((*mpstack).items, (*mpstack).capacity * sizeof((*mpstack).items[0]))))), 0) : 0), ((*mpstack).items + ((*mpstack).size++))) = (((MPConvStackVal) { .tv = tv, .type = kMPConvList, .saved_copyID = saved_copyID, .data = { .l = { .list = val_di->di_tv.vval.v_list, .li = tv_list_first(val_di->di_tv.vval.v_list), }, }, })));
break;
}
case kMPMap: {
if (val_di->di_tv.v_type != VAR_LIST) {
goto _convert_one_value_regular_dict;
}
list_T *const val_list = val_di->di_tv.vval.v_list;
if (val_list == ((void *)0) || tv_list_len(val_list) == 0) {
do {
(void) ((!!((void *)&_typval_encode_nothing_nodict_var != (void *)&_typval_encode_nothing_nodict_var))
|| (_assert("(void *)&_typval_encode_nothing_nodict_var != (void *)&TYPVAL_ENCODE_NODICT_VAR",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",545),0));
_nothing_conv_empty_dict(tv, ((dict_T **)&_typval_encode_nothing_nodict_var));
} while (0);
break;
}
do {
const list_T *const l_ = (val_list);
if (l_ != ((void *)0)) {
for (const listitem_T *li = l_->lv_first; li != ((void *)0) ; li = li->li_next) {
{
if ((&(li)->li_tv)->v_type != VAR_LIST || tv_list_len((&(li)->li_tv)->vval.v_list) != 2) {
goto _convert_one_value_regular_dict;
}
}
}
}
} while (0);
const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
do {
const int te_csr_ret = _typval_encode_nothing_check_self_reference(ignored, (val_list), &(val_list)->lv_copyID, mpstack, copyID, kMPConvPairs, objname); if (te_csr_ret != 2) {
return te_csr_ret;
}
} while (0);
(void) ((!!(saved_copyID != copyID && saved_copyID != copyID - 1))
|| (_assert("saved_copyID != copyID && saved_copyID != copyID - 1",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",560),0));
(*((((*mpstack).size == (*mpstack).capacity) ? (((*mpstack).capacity = (((*mpstack).capacity << 1) > ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).capacity << 1) : ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0])))))), (*mpstack).items = ((*mpstack).capacity == ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).items == (*mpstack).init_array ? (*mpstack).items : _memcpy_free((*mpstack).init_array, (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0]))) : ((*mpstack).items == (*mpstack).init_array ? memcpy(xmalloc((*mpstack).capacity * sizeof((*mpstack).items[0])), (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0])) : xrealloc((*mpstack).items, (*mpstack).capacity * sizeof((*mpstack).items[0]))))), 0) : 0), ((*mpstack).items + ((*mpstack).size++))) = (((MPConvStackVal) { .tv = tv, .type = kMPConvPairs, .saved_copyID = saved_copyID, .data = { .l = { .list = val_list, .li = tv_list_first(val_list), }, }, })));
break;
}
case kMPExt: {
const list_T *val_list;
varnumber_T type;
if (val_di->di_tv.v_type != VAR_LIST
|| tv_list_len((val_list = val_di->di_tv.vval.v_list)) != 2
|| ((&(tv_list_first(val_list))->li_tv)->v_type != VAR_NUMBER)
|| ((type = (&(tv_list_first(val_list))->li_tv)->vval.v_number) > 127)
|| type < (-128)
|| ((&(tv_list_last(val_list))->li_tv)->v_type != VAR_LIST)) {
goto _convert_one_value_regular_dict;
}
size_t len;
char *buf;
if (!(encode_vim_list_to_buf((&(tv_list_last(val_list))->li_tv)->vval.v_list, &len, &buf))) {
goto _convert_one_value_regular_dict;
};
xfree(buf);
break;
}
}
break;
}
_convert_one_value_regular_dict: {}
const int saved_copyID = tv->vval.v_dict->dv_copyID;
do {
const int te_csr_ret =
_typval_encode_nothing_check_self_reference(ignored, (tv->vval.v_dict), &(tv->vval.v_dict)->dv_copyID, mpstack, copyID, kMPConvDict, objname);
if (te_csr_ret != 2) {
return te_csr_ret;
}
} while (0);
(void) ((!!(saved_copyID != copyID))
|| (_assert("saved_copyID != copyID",
"C:/src/neovim/src/nvim/eval/typval_encode.c.h",610),0));
(*((((*mpstack).size == (*mpstack).capacity) ? (((*mpstack).capacity = (((*mpstack).capacity << 1) > ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).capacity << 1) : ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0])))))), (*mpstack).items = ((*mpstack).capacity == ((sizeof((*mpstack).init_array)/sizeof(((*mpstack).init_array)[0])) / ((size_t)(!(sizeof((*mpstack).init_array) % sizeof(((*mpstack).init_array)[0]))))) ? ((*mpstack).items == (*mpstack).init_array ? (*mpstack).items : _memcpy_free((*mpstack).init_array, (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0]))) : ((*mpstack).items == (*mpstack).init_array ? memcpy(xmalloc((*mpstack).capacity * sizeof((*mpstack).items[0])), (*mpstack).items, (*mpstack).size * sizeof((*mpstack).items[0])) : xrealloc((*mpstack).items, (*mpstack).capacity * sizeof((*mpstack).items[0]))))), 0) : 0), ((*mpstack).items + ((*mpstack).size++))) = (((MPConvStackVal) { .tv = tv, .type = kMPConvDict, .saved_copyID = saved_copyID, .data = { .d = { .dict = tv->vval.v_dict, .dictp = &tv->vval.v_dict, .hi = tv->vval.v_dict->dv_hashtab.ht_array, .todo = tv->vval.v_dict->dv_hashtab.ht_used, }, }, })));
do {
if (_nothing_conv_real_dict_after_start(tv, (dict_T **)&tv->vval.v_dict, (void *)&_typval_encode_nothing_nodict_var, &((*mpstack).items[(((*mpstack).size) - (0) - 1)])) != 2)
{
goto typval_encode_stop_converting_one_item;
}
} while (0);
break;
}
case VAR_UNKNOWN: {
internal_error("_typval_encode_nothing_convert_one_value" "()");
return 0;
}
}
typval_encode_stop_converting_one_item:
return 1;
goto typval_encode_stop_converting_one_item;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment