#define USING_FLOAT_STUFF
#include "vim.h"
#if defined(FEAT_EVAL) || defined(PROTO)
static int json_encode_item(garray_T *gap, typval_T *val, int copyID, int options);
static char e_json_error[] = N_("E491: json decode error at '%s'");
static int
json_encode_gap(garray_T *gap, typval_T *val, int options)
{
if (json_encode_item(gap, val, get_copyID(), options) == FAIL)
{
ga_clear(gap);
gap->ga_data = vim_strsave((char_u *)"");
return FAIL;
}
return OK;
}
char_u *
json_encode(typval_T *val, int options)
{
garray_T ga;
ga_init2(&ga, 1, 4000);
json_encode_gap(&ga, val, options);
ga_append(&ga, NUL);
return ga.ga_data;
}
#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
char_u *
json_encode_nr_expr(int nr, typval_T *val, int options)
{
typval_T listtv;
typval_T nrtv;
garray_T ga;
nrtv.v_type = VAR_NUMBER;
nrtv.vval.v_number = nr;
if (rettv_list_alloc(&listtv) == FAIL)
return NULL;
if (list_append_tv(listtv.vval.v_list, &nrtv) == FAIL
|| list_append_tv(listtv.vval.v_list, val) == FAIL)
{
list_unref(listtv.vval.v_list);
return NULL;
}
ga_init2(&ga, 1, 4000);
if (json_encode_gap(&ga, &listtv, options) == OK && (options & JSON_NL))
ga_append(&ga, '\n');
list_unref(listtv.vval.v_list);
ga_append(&ga, NUL);
return ga.ga_data;
}
#endif
static void
write_string(garray_T *gap, char_u *str)
{
char_u *res = str;
char_u numbuf[NUMBUFLEN];
if (res == NULL)
ga_concat(gap, (char_u *)"\"\"");
else
{
#if defined(USE_ICONV)
vimconv_T conv;
char_u *converted = NULL;
if (!enc_utf8)
{
conv.vc_type = CONV_NONE;
convert_setup(&conv, p_enc, (char_u*)"utf-8");
if (conv.vc_type != CONV_NONE)
converted = res = string_convert(&conv, res, NULL);
convert_setup(&conv, NULL, NULL);
}
#endif
ga_append(gap, '"');
while (*res != NUL)
{
int c;
c = utf_ptr2char(res);
switch (c)
{
case 0x08:
ga_append(gap, '\\'); ga_append(gap, 'b'); break;
case 0x09:
ga_append(gap, '\\'); ga_append(gap, 't'); break;
case 0x0a:
ga_append(gap, '\\'); ga_append(gap, 'n'); break;
case 0x0c:
ga_append(gap, '\\'); ga_append(gap, 'f'); break;
case 0x0d:
ga_append(gap, '\\'); ga_append(gap, 'r'); break;
case 0x22: case 0x5c: ga_append(gap, '\\');
ga_append(gap, c);
break;
default:
if (c >= 0x20)
{
numbuf[utf_char2bytes(c, numbuf)] = NUL;
ga_concat(gap, numbuf);
}
else
{
vim_snprintf((char *)numbuf, NUMBUFLEN,
"\\u%04lx", (long)c);
ga_concat(gap, numbuf);
}
}
res += utf_ptr2len(res);
}
ga_append(gap, '"');
#if defined(USE_ICONV)
vim_free(converted);
#endif
}
}
static int
is_simple_key(char_u *key)
{
char_u *p;
if (!ASCII_ISALPHA(*key))
return FALSE;
for (p = key + 1; *p != NUL; ++p)
if (!ASCII_ISALPHA(*p) && *p != '_' && !vim_isdigit(*p))
return FALSE;
return TRUE;
}
static int
json_encode_item(garray_T *gap, typval_T *val, int copyID, int options)
{
char_u numbuf[NUMBUFLEN];
char_u *res;
blob_T *b;
list_T *l;
dict_T *d;
int i;
switch (val->v_type)
{
case VAR_BOOL:
switch ((long)val->vval.v_number)
{
case VVAL_FALSE: ga_concat(gap, (char_u *)"false"); break;
case VVAL_TRUE: ga_concat(gap, (char_u *)"true"); break;
}
break;
case VAR_SPECIAL:
switch ((long)val->vval.v_number)
{
case VVAL_NONE: if ((options & JSON_JS) != 0
&& (options & JSON_NO_NONE) == 0)
break;
case VVAL_NULL: ga_concat(gap, (char_u *)"null"); break;
}
break;
case VAR_NUMBER:
vim_snprintf((char *)numbuf, NUMBUFLEN, "%lld",
(varnumber_T)val->vval.v_number);
ga_concat(gap, numbuf);
break;
case VAR_STRING:
res = val->vval.v_string;
write_string(gap, res);
break;
case VAR_FUNC:
case VAR_PARTIAL:
case VAR_JOB:
case VAR_CHANNEL:
emsg(_(e_invarg));
return FAIL;
case VAR_BLOB:
b = val->vval.v_blob;
if (b == NULL || b->bv_ga.ga_len == 0)
ga_concat(gap, (char_u *)"[]");
else
{
ga_append(gap, '[');
for (i = 0; i < b->bv_ga.ga_len; i++)
{
if (i > 0)
ga_concat(gap, (char_u *)",");
vim_snprintf((char *)numbuf, NUMBUFLEN, "%d",
(int)blob_get(b, i));
ga_concat(gap, numbuf);
}
ga_append(gap, ']');
}
break;
case VAR_LIST:
l = val->vval.v_list;
if (l == NULL)
ga_concat(gap, (char_u *)"[]");
else
{
if (l->lv_copyID == copyID)
ga_concat(gap, (char_u *)"[]");
else
{
listitem_T *li;
l->lv_copyID = copyID;
ga_append(gap, '[');
CHECK_LIST_MATERIALIZE(l);
for (li = l->lv_first; li != NULL && !got_int; )
{
if (json_encode_item(gap, &li->li_tv, copyID,
options & JSON_JS) == FAIL)
return FAIL;
if ((options & JSON_JS)
&& li->li_next == NULL
&& li->li_tv.v_type == VAR_SPECIAL
&& li->li_tv.vval.v_number == VVAL_NONE)
ga_append(gap, ',');
li = li->li_next;
if (li != NULL)
ga_append(gap, ',');
}
ga_append(gap, ']');
l->lv_copyID = 0;
}
}
break;
case VAR_DICT:
d = val->vval.v_dict;
if (d == NULL)
ga_concat(gap, (char_u *)"{}");
else
{
if (d->dv_copyID == copyID)
ga_concat(gap, (char_u *)"{}");
else
{
int first = TRUE;
int todo = (int)d->dv_hashtab.ht_used;
hashitem_T *hi;
d->dv_copyID = copyID;
ga_append(gap, '{');
for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int;
++hi)
if (!HASHITEM_EMPTY(hi))
{
--todo;
if (first)
first = FALSE;
else
ga_append(gap, ',');
if ((options & JSON_JS)
&& is_simple_key(hi->hi_key))
ga_concat(gap, hi->hi_key);
else
write_string(gap, hi->hi_key);
ga_append(gap, ':');
if (json_encode_item(gap, &dict_lookup(hi)->di_tv,
copyID, options | JSON_NO_NONE) == FAIL)
return FAIL;
}
ga_append(gap, '}');
d->dv_copyID = 0;
}
}
break;
case VAR_FLOAT:
#ifdef FEAT_FLOAT
# if defined(HAVE_MATH_H)
if (isnan(val->vval.v_float))
ga_concat(gap, (char_u *)"NaN");
else if (isinf(val->vval.v_float))
{
if (val->vval.v_float < 0.0)
ga_concat(gap, (char_u *)"-Infinity");
else
ga_concat(gap, (char_u *)"Infinity");
}
else
# endif
{
vim_snprintf((char *)numbuf, NUMBUFLEN, "%g",
val->vval.v_float);
ga_concat(gap, numbuf);
}
break;
#endif
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
internal_error_no_abort("json_encode_item()");
return FAIL;
}
return OK;
}
static void
fill_numbuflen(js_read_T *reader)
{
if (reader->js_fill != NULL && (int)(reader->js_end - reader->js_buf)
- reader->js_used < NUMBUFLEN)
{
if (reader->js_fill(reader))
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
}
}
static void
json_skip_white(js_read_T *reader)
{
int c;
for (;;)
{
c = reader->js_buf[reader->js_used];
if (reader->js_fill != NULL && c == NUL)
{
if (reader->js_fill(reader))
{
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
continue;
}
}
if (c == NUL || c > ' ')
break;
++reader->js_used;
}
fill_numbuflen(reader);
}
static int
json_decode_string(js_read_T *reader, typval_T *res, int quote)
{
garray_T ga;
int len;
char_u *p;
int c;
varnumber_T nr;
if (res != NULL)
ga_init2(&ga, 1, 200);
p = reader->js_buf + reader->js_used + 1; while (*p != quote)
{
if (*p == NUL || p[1] == NUL || utf_ptr2len(p) < utf_byte2len(*p))
{
if (reader->js_fill == NULL)
break;
len = (int)(reader->js_end - p);
reader->js_used = (int)(p - reader->js_buf);
if (!reader->js_fill(reader))
break; p = reader->js_buf + reader->js_used;
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
continue;
}
if (*p == '\\')
{
c = -1;
switch (p[1])
{
case '\\': c = '\\'; break;
case '"': c = '"'; break;
case 'b': c = BS; break;
case 't': c = TAB; break;
case 'n': c = NL; break;
case 'f': c = FF; break;
case 'r': c = CAR; break;
case 'u':
if (reader->js_fill != NULL
&& (int)(reader->js_end - p) < NUMBUFLEN)
{
reader->js_used = (int)(p - reader->js_buf);
if (reader->js_fill(reader))
{
p = reader->js_buf + reader->js_used;
reader->js_end = reader->js_buf
+ STRLEN(reader->js_buf);
}
}
nr = 0;
len = 0;
vim_str2nr(p + 2, NULL, &len,
STR2NR_HEX + STR2NR_FORCE, &nr, NULL, 4, TRUE);
if (len == 0)
{
if (res != NULL)
ga_clear(&ga);
return FAIL;
}
p += len + 2;
if (0xd800 <= nr && nr <= 0xdfff
&& (int)(reader->js_end - p) >= 6
&& *p == '\\' && *(p+1) == 'u')
{
varnumber_T nr2 = 0;
len = 0;
vim_str2nr(p + 2, NULL, &len,
STR2NR_HEX + STR2NR_FORCE, &nr2, NULL, 4, TRUE);
if (len == 0)
{
if (res != NULL)
ga_clear(&ga);
return FAIL;
}
if (0xdc00 <= nr2 && nr2 <= 0xdfff)
{
p += len + 2;
nr = (((nr - 0xd800) << 10) |
((nr2 - 0xdc00) & 0x3ff)) + 0x10000;
}
}
if (res != NULL)
{
char_u buf[NUMBUFLEN];
buf[utf_char2bytes((int)nr, buf)] = NUL;
ga_concat(&ga, buf);
}
break;
default:
++p;
continue;
}
if (c > 0)
{
p += 2;
if (res != NULL)
ga_append(&ga, c);
}
}
else
{
len = utf_ptr2len(p);
if (res != NULL)
{
if (ga_grow(&ga, len) == FAIL)
{
ga_clear(&ga);
return FAIL;
}
mch_memmove((char *)ga.ga_data + ga.ga_len, p, (size_t)len);
ga.ga_len += len;
}
p += len;
}
}
reader->js_used = (int)(p - reader->js_buf);
if (*p == quote)
{
++reader->js_used;
if (res != NULL)
{
ga_append(&ga, NUL);
res->v_type = VAR_STRING;
#if defined(USE_ICONV)
if (!enc_utf8)
{
vimconv_T conv;
conv.vc_type = CONV_NONE;
convert_setup(&conv, (char_u*)"utf-8", p_enc);
if (conv.vc_type != CONV_NONE)
{
res->vval.v_string =
string_convert(&conv, ga.ga_data, NULL);
vim_free(ga.ga_data);
}
convert_setup(&conv, NULL, NULL);
}
else
#endif
res->vval.v_string = ga.ga_data;
}
return OK;
}
if (res != NULL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NONE;
ga_clear(&ga);
}
return MAYBE;
}
typedef enum {
JSON_ARRAY, JSON_OBJECT_KEY, JSON_OBJECT } json_decode_T;
typedef struct {
json_decode_T jd_type;
typval_T jd_tv; typval_T jd_key_tv;
char_u *jd_key;
} json_dec_item_T;
static int
json_decode_item(js_read_T *reader, typval_T *res, int options)
{
char_u *p;
int len;
int retval;
garray_T stack;
typval_T item;
typval_T *cur_item;
json_dec_item_T *top_item;
char_u key_buf[NUMBUFLEN];
ga_init2(&stack, sizeof(json_dec_item_T), 100);
cur_item = res;
init_tv(&item);
if (res != NULL)
init_tv(res);
fill_numbuflen(reader);
p = reader->js_buf + reader->js_used;
for (;;)
{
top_item = NULL;
if (stack.ga_len > 0)
{
top_item = ((json_dec_item_T *)stack.ga_data) + stack.ga_len - 1;
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == NUL)
{
retval = MAYBE;
if (top_item->jd_type == JSON_OBJECT)
clear_tv(&top_item->jd_key_tv);
goto theend;
}
if (top_item->jd_type == JSON_OBJECT_KEY
|| top_item->jd_type == JSON_ARRAY)
{
if (*p == (top_item->jd_type == JSON_ARRAY ? ']' : '}'))
{
++reader->js_used; --stack.ga_len;
if (stack.ga_len == 0)
{
retval = OK;
goto theend;
}
if (cur_item != NULL)
cur_item = &top_item->jd_tv;
goto item_end;
}
}
}
if (top_item != NULL && top_item->jd_type == JSON_OBJECT_KEY
&& (options & JSON_JS)
&& reader->js_buf[reader->js_used] != '"'
&& reader->js_buf[reader->js_used] != '\''
&& reader->js_buf[reader->js_used] != '['
&& reader->js_buf[reader->js_used] != '{')
{
char_u *key;
key = p = reader->js_buf + reader->js_used;
while (*p != NUL && *p != ':' && *p > ' ')
++p;
if (cur_item != NULL)
{
cur_item->v_type = VAR_STRING;
cur_item->vval.v_string = vim_strnsave(key, (int)(p - key));
top_item->jd_key = cur_item->vval.v_string;
}
reader->js_used += (int)(p - key);
}
else
{
switch (*p)
{
case '[': if (top_item && top_item->jd_type == JSON_OBJECT_KEY)
{
retval = FAIL;
break;
}
if (ga_grow(&stack, 1) == FAIL)
{
retval = FAIL;
break;
}
if (cur_item != NULL && rettv_list_alloc(cur_item) == FAIL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
retval = FAIL;
break;
}
++reader->js_used; top_item = ((json_dec_item_T *)stack.ga_data)
+ stack.ga_len;
top_item->jd_type = JSON_ARRAY;
++stack.ga_len;
if (cur_item != NULL)
{
top_item->jd_tv = *cur_item;
cur_item = &item;
}
continue;
case '{': if (top_item && top_item->jd_type == JSON_OBJECT_KEY)
{
retval = FAIL;
break;
}
if (ga_grow(&stack, 1) == FAIL)
{
retval = FAIL;
break;
}
if (cur_item != NULL && rettv_dict_alloc(cur_item) == FAIL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
retval = FAIL;
break;
}
++reader->js_used; top_item = ((json_dec_item_T *)stack.ga_data)
+ stack.ga_len;
top_item->jd_type = JSON_OBJECT_KEY;
++stack.ga_len;
if (cur_item != NULL)
{
top_item->jd_tv = *cur_item;
cur_item = &top_item->jd_key_tv;
}
continue;
case '"': retval = json_decode_string(reader, cur_item, *p);
break;
case '\'':
if (options & JSON_JS)
retval = json_decode_string(reader, cur_item, *p);
else
{
semsg(_(e_json_error), p);
retval = FAIL;
}
break;
case ',': if ((options & JSON_JS) == 0)
{
semsg(_(e_json_error), p);
retval = FAIL;
break;
}
case NUL: if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
}
retval = OK;
break;
default:
if (VIM_ISDIGIT(*p) || (*p == '-'
&& (VIM_ISDIGIT(p[1]) || p[1] == NUL)))
{
char_u *sp = p;
if (*sp == '-')
{
++sp;
if (*sp == NUL)
{
retval = MAYBE;
break;
}
if (!VIM_ISDIGIT(*sp))
{
semsg(_(e_json_error), p);
retval = FAIL;
break;
}
}
sp = skipdigits(sp);
#ifdef FEAT_FLOAT
if (*sp == '.' || *sp == 'e' || *sp == 'E')
{
if (cur_item == NULL)
{
float_T f;
len = string2float(p, &f);
}
else
{
cur_item->v_type = VAR_FLOAT;
len = string2float(p, &cur_item->vval.v_float);
}
}
else
#endif
{
varnumber_T nr;
vim_str2nr(reader->js_buf + reader->js_used,
NULL, &len, 0, &nr, NULL, 0, TRUE);
if (len == 0)
{
semsg(_(e_json_error), p);
retval = FAIL;
goto theend;
}
if (cur_item != NULL)
{
cur_item->v_type = VAR_NUMBER;
cur_item->vval.v_number = nr;
}
}
reader->js_used += len;
retval = OK;
break;
}
if (STRNICMP((char *)p, "false", 5) == 0)
{
reader->js_used += 5;
if (cur_item != NULL)
{
cur_item->v_type = VAR_BOOL;
cur_item->vval.v_number = VVAL_FALSE;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "true", 4) == 0)
{
reader->js_used += 4;
if (cur_item != NULL)
{
cur_item->v_type = VAR_BOOL;
cur_item->vval.v_number = VVAL_TRUE;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "null", 4) == 0)
{
reader->js_used += 4;
if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NULL;
}
retval = OK;
break;
}
#ifdef FEAT_FLOAT
if (STRNICMP((char *)p, "NaN", 3) == 0)
{
reader->js_used += 3;
if (cur_item != NULL)
{
cur_item->v_type = VAR_FLOAT;
cur_item->vval.v_float = NAN;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "-Infinity", 9) == 0)
{
reader->js_used += 9;
if (cur_item != NULL)
{
cur_item->v_type = VAR_FLOAT;
cur_item->vval.v_float = -INFINITY;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "Infinity", 8) == 0)
{
reader->js_used += 8;
if (cur_item != NULL)
{
cur_item->v_type = VAR_FLOAT;
cur_item->vval.v_float = INFINITY;
}
retval = OK;
break;
}
#endif
len = (int)(reader->js_end
- (reader->js_buf + reader->js_used));
if (
(len < 5 && STRNICMP((char *)p, "false", len) == 0)
#ifdef FEAT_FLOAT
|| (len < 9 && STRNICMP((char *)p, "-Infinity", len) == 0)
|| (len < 8 && STRNICMP((char *)p, "Infinity", len) == 0)
|| (len < 3 && STRNICMP((char *)p, "NaN", len) == 0)
#endif
|| (len < 4 && (STRNICMP((char *)p, "true", len) == 0
|| STRNICMP((char *)p, "null", len) == 0)))
retval = MAYBE;
else
retval = FAIL;
break;
}
if (retval == FAIL)
break;
if (retval == MAYBE || stack.ga_len == 0)
goto theend;
if (top_item != NULL && top_item->jd_type == JSON_OBJECT_KEY
&& cur_item != NULL)
{
top_item->jd_key = tv_get_string_buf_chk(cur_item, key_buf);
if (top_item->jd_key == NULL)
{
clear_tv(cur_item);
emsg(_(e_invarg));
retval = FAIL;
goto theend;
}
}
}
item_end:
top_item = ((json_dec_item_T *)stack.ga_data) + stack.ga_len - 1;
switch (top_item->jd_type)
{
case JSON_ARRAY:
if (res != NULL)
{
listitem_T *li = listitem_alloc();
if (li == NULL)
{
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
li->li_tv = *cur_item;
list_append(top_item->jd_tv.vval.v_list, li);
}
if (cur_item != NULL)
cur_item = &item;
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == ',')
++reader->js_used;
else if (*p != ']')
{
if (*p == NUL)
retval = MAYBE;
else
{
semsg(_(e_json_error), p);
retval = FAIL;
}
goto theend;
}
break;
case JSON_OBJECT_KEY:
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p != ':')
{
if (cur_item != NULL)
clear_tv(cur_item);
if (*p == NUL)
retval = MAYBE;
else
{
semsg(_(e_json_error), p);
retval = FAIL;
}
goto theend;
}
++reader->js_used;
json_skip_white(reader);
top_item->jd_type = JSON_OBJECT;
if (cur_item != NULL)
cur_item = &item;
break;
case JSON_OBJECT:
if (cur_item != NULL
&& dict_find(top_item->jd_tv.vval.v_dict,
top_item->jd_key, -1) != NULL)
{
semsg(_("E938: Duplicate key in JSON: \"%s\""),
top_item->jd_key);
clear_tv(&top_item->jd_key_tv);
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
if (cur_item != NULL)
{
dictitem_T *di = dictitem_alloc(top_item->jd_key);
clear_tv(&top_item->jd_key_tv);
if (di == NULL)
{
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
di->di_tv = *cur_item;
di->di_tv.v_lock = 0;
if (dict_add(top_item->jd_tv.vval.v_dict, di) == FAIL)
{
dictitem_free(di);
retval = FAIL;
goto theend;
}
}
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == ',')
++reader->js_used;
else if (*p != '}')
{
if (*p == NUL)
retval = MAYBE;
else
{
semsg(_(e_json_error), p);
retval = FAIL;
}
goto theend;
}
top_item->jd_type = JSON_OBJECT_KEY;
if (cur_item != NULL)
cur_item = &top_item->jd_key_tv;
break;
}
}
if (res != NULL)
{
clear_tv(res);
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NONE;
}
semsg(_(e_json_error), p);
theend:
ga_clear(&stack);
return retval;
}
static int
json_decode_all(js_read_T *reader, typval_T *res, int options)
{
int ret;
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
json_skip_white(reader);
ret = json_decode_item(reader, res, options);
if (ret != OK)
{
if (ret == MAYBE)
semsg(_(e_json_error), reader->js_buf);
return FAIL;
}
json_skip_white(reader);
if (reader->js_buf[reader->js_used] != NUL)
{
emsg(_(e_trailing));
return FAIL;
}
return OK;
}
#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
int
json_decode(js_read_T *reader, typval_T *res, int options)
{
int ret;
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
json_skip_white(reader);
ret = json_decode_item(reader, res, options);
json_skip_white(reader);
return ret;
}
#endif
int
json_find_end(js_read_T *reader, int options)
{
int used_save = reader->js_used;
int ret;
reader->js_end = reader->js_buf + STRLEN(reader->js_buf);
json_skip_white(reader);
ret = json_decode_item(reader, NULL, options);
reader->js_used = used_save;
return ret;
}
void
f_js_decode(typval_T *argvars, typval_T *rettv)
{
js_read_T reader;
reader.js_buf = tv_get_string(&argvars[0]);
reader.js_fill = NULL;
reader.js_used = 0;
if (json_decode_all(&reader, rettv, JSON_JS) != OK)
emsg(_(e_invarg));
}
void
f_js_encode(typval_T *argvars, typval_T *rettv)
{
rettv->v_type = VAR_STRING;
rettv->vval.v_string = json_encode(&argvars[0], JSON_JS);
}
void
f_json_decode(typval_T *argvars, typval_T *rettv)
{
js_read_T reader;
reader.js_buf = tv_get_string(&argvars[0]);
reader.js_fill = NULL;
reader.js_used = 0;
json_decode_all(&reader, rettv, 0);
}
void
f_json_encode(typval_T *argvars, typval_T *rettv)
{
rettv->v_type = VAR_STRING;
rettv->vval.v_string = json_encode(&argvars[0], 0);
}
#endif