src/json.c

/* vi:set ts=8 sts=4 sw=4:
 *
 * VIM - Vi IMproved	by Bram Moolenaar
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 * See README.txt for an overview of the Vim source code.
 */

/*
 * json.c: Encoding and decoding JSON.
 *
 * Follows this standard: https://tools.ietf.org/html/rfc7159.html
 */

#include "vim.h"

#if defined(FEAT_EVAL) || defined(PROTO)
static int json_encode_item(garray_T *gap, typval_T *val, int copyID);
static void json_decode_item(js_read_T *reader, typval_T *res);

/*
 * Encode "val" into a JSON format string.
 */
    char_u *
json_encode(typval_T *val)
{
    garray_T ga;

    /* Store bytes in the growarray. */
    ga_init2(&ga, 1, 4000);
    json_encode_item(&ga, val, get_copyID());
    return ga.ga_data;
}

/*
 * Encode ["nr", "val"] into a JSON format string.
 * Returns NULL when out of memory.
 */
    char_u *
json_encode_nr_expr(int nr, typval_T *val)
{
    typval_T	listtv;
    typval_T	nrtv;
    char_u	*text;

    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;
    }

    text = json_encode(&listtv);
    list_unref(listtv.vval.v_list);
    return text;
}

    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 *)"null");
    else
    {
	ga_append(gap, '"');
	while (*res != NUL)
	{
	    int c = 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)
		    {
#ifdef FEAT_MBYTE
			numbuf[mb_char2bytes(c, numbuf)] = NUL;
#else
			numbuf[0] = c;
			numbuf[1] = NUL;
#endif
			ga_concat(gap, numbuf);
		    }
		    else
		    {
			vim_snprintf((char *)numbuf, NUMBUFLEN,
							 "\\u%04lx", (long)c);
			ga_concat(gap, numbuf);
		    }
	    }
	    mb_cptr_adv(res);
	}
	ga_append(gap, '"');
    }
}

/*
 * Encode "val" into "gap".
 * Return FAIL or OK.
 */
    static int
json_encode_item(garray_T *gap, typval_T *val, int copyID)
{
    char_u	numbuf[NUMBUFLEN];
    char_u	*res;
    list_T	*l;
    dict_T	*d;

    switch (val->v_type)
    {
	case VAR_SPECIAL:
	    switch (val->vval.v_number)
	    {
		case VVAL_FALSE: ga_concat(gap, (char_u *)"false"); break;
		case VVAL_TRUE: ga_concat(gap, (char_u *)"true"); break;
		case VVAL_NONE: break;
		case VVAL_NULL: ga_concat(gap, (char_u *)"null"); break;
	    }
	    break;

	case VAR_NUMBER:
	    vim_snprintf((char *)numbuf, NUMBUFLEN, "%ld",
						    (long)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:
	    /* no JSON equivalent */
	    EMSG(_(e_invarg));
	    return FAIL;

	case VAR_LIST:
	    l = val->vval.v_list;
	    if (l == NULL)
		ga_concat(gap, (char_u *)"null");
	    else
	    {
		if (l->lv_copyID == copyID)
		    ga_concat(gap, (char_u *)"[]");
		else
		{
		    listitem_T	*li;

		    l->lv_copyID = copyID;
		    ga_append(gap, '[');
		    for (li = l->lv_first; li != NULL && !got_int; )
		    {
			if (json_encode_item(gap, &li->li_tv, copyID) == FAIL)
			    return FAIL;
			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 *)"null");
	    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, ',');
			    write_string(gap, hi->hi_key);
			    ga_append(gap, ':');
			    if (json_encode_item(gap, &dict_lookup(hi)->di_tv,
							      copyID) == FAIL)
				return FAIL;
			}
		    ga_append(gap, '}');
		    d->dv_copyID = 0;
		}
	    }
	    break;

#ifdef FEAT_FLOAT
	case VAR_FLOAT:
	    vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", val->vval.v_float);
	    ga_concat(gap, numbuf);
	    break;
#endif
	default: EMSG2(_(e_intern2), "json_encode_item()"); break;
		 return FAIL;
    }
    return OK;
}

/*
 * Skip white space in "reader".
 */
    static void
json_skip_white(js_read_T *reader)
{
    int c;

    while ((c = reader->js_buf[reader->js_used]) == ' '
					   || c == TAB || c == NL || c == CAR)
	++reader->js_used;
}

/*
 * Make sure there are at least enough characters buffered to read a number.
 */
    static void
json_fill_buffer(js_read_T *reader UNUSED)
{
    /* TODO */
}

    static void
json_decode_array(js_read_T *reader, typval_T *res)
{
    char_u	*p;
    typval_T	item;
    listitem_T	*li;

    if (rettv_list_alloc(res) == FAIL)
	goto failsilent;
    ++reader->js_used; /* consume the '[' */

    while (TRUE)
    {
	json_skip_white(reader);
	p = reader->js_buf + reader->js_used;
	if (*p == NUL)
	    goto fail;
	if (*p == ']')
	{
	    ++reader->js_used; /* consume the ']' */
	    return;
	}

	if (!reader->js_eof && (int)(reader->js_end - p) < NUMBUFLEN)
	    json_fill_buffer(reader);

	json_decode_item(reader, &item);
	li = listitem_alloc();
	if (li == NULL)
	    return;
	li->li_tv = item;
	list_append(res->vval.v_list, li);

	json_skip_white(reader);
	p = reader->js_buf + reader->js_used;
	if (*p == ',')
	    ++reader->js_used;
	else if (*p != ']')
	    goto fail;
    }
fail:
    EMSG(_(e_invarg));
failsilent:
    res->v_type = VAR_SPECIAL;
    res->vval.v_number = VVAL_NONE;
}

    static void
json_decode_object(js_read_T *reader, typval_T *res)
{
    char_u	*p;
    typval_T	tvkey;
    typval_T	item;
    dictitem_T	*di;
    char_u	buf[NUMBUFLEN];
    char_u	*key;

    if (rettv_dict_alloc(res) == FAIL)
	goto failsilent;
    ++reader->js_used; /* consume the '{' */

    while (TRUE)
    {
	json_skip_white(reader);
	p = reader->js_buf + reader->js_used;
	if (*p == NUL)
	    goto fail;
	if (*p == '}')
	{
	    ++reader->js_used; /* consume the '}' */
	    return;
	}

	if (!reader->js_eof && (int)(reader->js_end - p) < NUMBUFLEN)
	    json_fill_buffer(reader);
	json_decode_item(reader, &tvkey);
	key = get_tv_string_buf_chk(&tvkey, buf);
	if (key == NULL || *key == NUL)
	{
	    /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
	    if (key != NULL)
		EMSG(_(e_emptykey));
	    clear_tv(&tvkey);
	    goto failsilent;
	}

	json_skip_white(reader);
	p = reader->js_buf + reader->js_used;
	if (*p != ':')
	{
	    clear_tv(&tvkey);
	    goto fail;
	}
	++reader->js_used;
	json_skip_white(reader);

	if (!reader->js_eof && (int)(reader->js_end - p) < NUMBUFLEN)
	    json_fill_buffer(reader);
	json_decode_item(reader, &item);

	di = dictitem_alloc(key);
	clear_tv(&tvkey);
	if (di == NULL)
	{
	    clear_tv(&item);
	    goto fail;
	}
	di->di_tv = item;
	if (dict_add(res->vval.v_dict, di) == FAIL)
	    dictitem_free(di);

	json_skip_white(reader);
	p = reader->js_buf + reader->js_used;
	if (*p == ',')
	    ++reader->js_used;
	else if (*p != '}')
	    goto fail;
    }
fail:
    EMSG(_(e_invarg));
failsilent:
    res->v_type = VAR_SPECIAL;
    res->vval.v_number = VVAL_NONE;
}

    static void
json_decode_string(js_read_T *reader, typval_T *res)
{
    garray_T    ga;
    int		len;
    char_u	*p = reader->js_buf + reader->js_used + 1;
    int		c;
    long	nr;
    char_u	buf[NUMBUFLEN];

    ga_init2(&ga, 1, 200);

    /* TODO: fill buffer when needed. */
    while (*p != NUL && *p != '"')
    {
	if (*p == '\\')
	{
	    c = -1;
	    switch (p[1])
	    {
		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':
		    vim_str2nr(p + 2, NULL, &len,
				     STR2NR_HEX + STR2NR_FORCE, &nr, NULL, 4);
		    p += len + 2;
#ifdef FEAT_MBYTE
		    buf[(*mb_char2bytes)((int)nr, buf)] = NUL;
		    ga_concat(&ga, buf);
#else
		    ga_append(&ga, nr);
#endif
		    break;
		default: c = p[1]; break;
	    }
	    if (c > 0)
	    {
		p += 2;
		ga_append(&ga, c);
	    }
	}
	else
	{
	    len = MB_PTR2LEN(p);
	    if (ga_grow(&ga, len) == OK)
	    {
		mch_memmove((char *)ga.ga_data + ga.ga_len, p, (size_t)len);
		ga.ga_len += len;
	    }
	    p += len;
	}
	if (!reader->js_eof && (int)(reader->js_end - p) < NUMBUFLEN)
	{
	    reader->js_used = (int)(p - reader->js_buf);
	    json_fill_buffer(reader);
	    p = reader->js_buf + reader->js_used;
	}
    }
    reader->js_used = (int)(p - reader->js_buf);
    if (*p == '"')
    {
	++reader->js_used;
	res->v_type = VAR_STRING;
	if (ga.ga_data == NULL)
	    res->vval.v_string = NULL;
	else
	    res->vval.v_string = vim_strsave(ga.ga_data);
    }
    else
    {
	EMSG(_(e_invarg));
	res->v_type = VAR_SPECIAL;
	res->vval.v_number = VVAL_NONE;
    }
    ga_clear(&ga);
}

/*
 * Decode one item and put it in "result".
 * Must already have skipped white space.
 */
    static void
json_decode_item(js_read_T *reader, typval_T *res)
{
    char_u	*p = reader->js_buf + reader->js_used;

    switch (*p)
    {
	case '[': /* array */
	    json_decode_array(reader, res);
	    return;

	case '{': /* object */
	    json_decode_object(reader, res);
	    return;

	case '"': /* string */
	    json_decode_string(reader, res);
	    return;

	case ',': /* comma: empty item */
	case NUL: /* empty */
	    res->v_type = VAR_SPECIAL;
	    res->vval.v_number = VVAL_NONE;
	    return;

	default:
	    if (VIM_ISDIGIT(*p) || *p == '-')
	    {
		int	len;
		char_u  *sp = p;
#ifdef FEAT_FLOAT
		if (*sp == '-')
		    ++sp;
		sp = skipdigits(sp);
		if (*sp == '.' || *sp == 'e' || *sp == 'E')
		{
		    res->v_type = VAR_FLOAT;
		    len = string2float(p, &res->vval.v_float);
		}
		else
#endif
		{
		    long nr;

		    res->v_type = VAR_NUMBER;
		    vim_str2nr(reader->js_buf + reader->js_used,
			    NULL, &len, 0, /* what */
			    &nr, NULL, 0);
		    res->vval.v_number = nr;
		}
		reader->js_used += len;
		return;
	    }
	    if (STRNICMP((char *)p, "false", 5) == 0)
	    {
		reader->js_used += 5;
		res->v_type = VAR_SPECIAL;
		res->vval.v_number = VVAL_FALSE;
		return;
	    }
	    if (STRNICMP((char *)p, "true", 4) == 0)
	    {
		reader->js_used += 4;
		res->v_type = VAR_SPECIAL;
		res->vval.v_number = VVAL_TRUE;
		return;
	    }
	    if (STRNICMP((char *)p, "null", 4) == 0)
	    {
		reader->js_used += 4;
		res->v_type = VAR_SPECIAL;
		res->vval.v_number = VVAL_NULL;
		return;
	    }
	    break;
    }

    EMSG(_(e_invarg));
    res->v_type = VAR_SPECIAL;
    res->vval.v_number = VVAL_NONE;
}

/*
 * Decode the JSON from "reader" and store the result in "res".
 */
    void
json_decode(js_read_T *reader, typval_T *res)
{
    json_skip_white(reader);
    json_decode_item(reader, res);
    json_skip_white(reader);
    if (reader->js_buf[reader->js_used] != NUL)
	EMSG(_(e_invarg));
}
#endif