[qemu.git] / qobject / json-parser.c

/*
 * JSON Parser 
 *
 * Copyright IBM, Corp. 2009
 *
 * Authors:
 *  Anthony Liguori   <[email protected]>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include <stdarg.h>

#include "qemu-common.h"
#include "qapi/qmp/qstring.h"
#include "qapi/qmp/qint.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qlist.h"
#include "qapi/qmp/qfloat.h"
#include "qapi/qmp/qbool.h"
#include "qapi/qmp/json-parser.h"
#include "qapi/qmp/json-lexer.h"

typedef struct JSONParserContext
{
    Error *err;
    struct {
        QObject **buf;
        size_t pos;
        size_t count;
    } tokens;
} JSONParserContext;

#define BUG_ON(cond) assert(!(cond))

/**
 * TODO
 *
 * 0) make errors meaningful again
 * 1) add geometry information to tokens
 * 3) should we return a parsed size?
 * 4) deal with premature EOI
 */

static QObject *parse_value(JSONParserContext *ctxt, va_list *ap);

/**
 * Token manipulators
 *
 * tokens are dictionaries that contain a type, a string value, and geometry information
 * about a token identified by the lexer.  These are routines that make working with
 * these objects a bit easier.
 */
static const char *token_get_value(QObject *obj)
{
    return qdict_get_str(qobject_to_qdict(obj), "token");
}

static JSONTokenType token_get_type(QObject *obj)
{
    return qdict_get_int(qobject_to_qdict(obj), "type");
}

static int token_is_operator(QObject *obj, char op)
{
    const char *val;

    if (token_get_type(obj) != JSON_OPERATOR) {
        return 0;
    }

    val = token_get_value(obj);

    return (val[0] == op) && (val[1] == 0);
}

static int token_is_keyword(QObject *obj, const char *value)
{
    if (token_get_type(obj) != JSON_KEYWORD) {
        return 0;
    }

    return strcmp(token_get_value(obj), value) == 0;
}

static int token_is_escape(QObject *obj, const char *value)
{
    if (token_get_type(obj) != JSON_ESCAPE) {
        return 0;
    }

    return (strcmp(token_get_value(obj), value) == 0);
}

/**
 * Error handler
 */
static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
                                           QObject *token, const char *msg, ...)
{
    va_list ap;
    char message[1024];
    va_start(ap, msg);
    vsnprintf(message, sizeof(message), msg, ap);
    va_end(ap);
    if (ctxt->err) {
        error_free(ctxt->err);
        ctxt->err = NULL;
    }
    error_setg(&ctxt->err, "JSON parse error, %s", message);
}

/**
 * String helpers
 *
 * These helpers are used to unescape strings.
 */
static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
{
    if (wchar <= 0x007F) {
        BUG_ON(buffer_length < 2);

        buffer[0] = wchar & 0x7F;
        buffer[1] = 0;
    } else if (wchar <= 0x07FF) {
        BUG_ON(buffer_length < 3);

        buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F);
        buffer[1] = 0x80 | (wchar & 0x3F);
        buffer[2] = 0;
    } else {
        BUG_ON(buffer_length < 4);

        buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F);
        buffer[1] = 0x80 | ((wchar >> 6) & 0x3F);
        buffer[2] = 0x80 | (wchar & 0x3F);
        buffer[3] = 0;
    }
}

static int hex2decimal(char ch)
{
    if (ch >= '0' && ch <= '9') {
        return (ch - '0');
    } else if (ch >= 'a' && ch <= 'f') {
        return 10 + (ch - 'a');
    } else if (ch >= 'A' && ch <= 'F') {
        return 10 + (ch - 'A');
    }

    return -1;
}

/**
 * parse_string(): Parse a json string and return a QObject
 *
 *  string
 *      ""
 *      " chars "
 *  chars
 *      char
 *      char chars
 *  char
 *      any-Unicode-character-
 *          except-"-or-\-or-
 *          control-character
 *      \"
 *      \\
 *      \/
 *      \b
 *      \f
 *      \n
 *      \r
 *      \t
 *      \u four-hex-digits 
 */
static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token)
{
    const char *ptr = token_get_value(token);
    QString *str;
    int double_quote = 1;

    if (*ptr == '"') {
        double_quote = 1;
    } else {
        double_quote = 0;
    }
    ptr++;

    str = qstring_new();
    while (*ptr && 
           ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) {
        if (*ptr == '\\') {
            ptr++;

            switch (*ptr) {
            case '"':
                qstring_append(str, "\"");
                ptr++;
                break;
            case '\'':
                qstring_append(str, "'");
                ptr++;
                break;
            case '\\':
                qstring_append(str, "\\");
                ptr++;
                break;
            case '/':
                qstring_append(str, "/");
                ptr++;
                break;
            case 'b':
                qstring_append(str, "\b");
                ptr++;
                break;
            case 'f':
                qstring_append(str, "\f");
                ptr++;
                break;
            case 'n':
                qstring_append(str, "\n");
                ptr++;
                break;
            case 'r':
                qstring_append(str, "\r");
                ptr++;
                break;
            case 't':
                qstring_append(str, "\t");
                ptr++;
                break;
            case 'u': {
                uint16_t unicode_char = 0;
                char utf8_char[4];
                int i = 0;

                ptr++;

                for (i = 0; i < 4; i++) {
                    if (qemu_isxdigit(*ptr)) {
                        unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4);
                    } else {
                        parse_error(ctxt, token,
                                    "invalid hex escape sequence in string");
                        goto out;
                    }
                    ptr++;
                }

                wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
                qstring_append(str, utf8_char);
            }   break;
            default:
                parse_error(ctxt, token, "invalid escape sequence in string");
                goto out;
            }
        } else {
            char dummy[2];

            dummy[0] = *ptr++;
            dummy[1] = 0;

            qstring_append(str, dummy);
        }
    }

    return str;

out:
    QDECREF(str);
    return NULL;
}

static QObject *parser_context_pop_token(JSONParserContext *ctxt)
{
    QObject *token;
    g_assert(ctxt->tokens.pos < ctxt->tokens.count);
    token = ctxt->tokens.buf[ctxt->tokens.pos];
    ctxt->tokens.pos++;
    return token;
}

/* Note: parser_context_{peek|pop}_token do not increment the
 * token object's refcount. In both cases the references will continue
 * to be tracked and cleaned up in parser_context_free(), so do not
 * attempt to free the token object.
 */
static QObject *parser_context_peek_token(JSONParserContext *ctxt)
{
    QObject *token;
    g_assert(ctxt->tokens.pos < ctxt->tokens.count);
    token = ctxt->tokens.buf[ctxt->tokens.pos];
    return token;
}

static JSONParserContext parser_context_save(JSONParserContext *ctxt)
{
    JSONParserContext saved_ctxt = {0};
    saved_ctxt.tokens.pos = ctxt->tokens.pos;
    saved_ctxt.tokens.count = ctxt->tokens.count;
    saved_ctxt.tokens.buf = ctxt->tokens.buf;
    return saved_ctxt;
}

static void parser_context_restore(JSONParserContext *ctxt,
                                   JSONParserContext saved_ctxt)
{
    ctxt->tokens.pos = saved_ctxt.tokens.pos;
    ctxt->tokens.count = saved_ctxt.tokens.count;
    ctxt->tokens.buf = saved_ctxt.tokens.buf;
}

static void tokens_append_from_iter(QObject *obj, void *opaque)
{
    JSONParserContext *ctxt = opaque;
    g_assert(ctxt->tokens.pos < ctxt->tokens.count);
    ctxt->tokens.buf[ctxt->tokens.pos++] = obj;
    qobject_incref(obj);
}

static JSONParserContext *parser_context_new(QList *tokens)
{
    JSONParserContext *ctxt;
    size_t count;

    if (!tokens) {
        return NULL;
    }

    count = qlist_size(tokens);
    if (count == 0) {
        return NULL;
    }

    ctxt = g_malloc0(sizeof(JSONParserContext));
    ctxt->tokens.pos = 0;
    ctxt->tokens.count = count;
    ctxt->tokens.buf = g_malloc(count * sizeof(QObject *));
    qlist_iter(tokens, tokens_append_from_iter, ctxt);
    ctxt->tokens.pos = 0;

    return ctxt;
}

/* to support error propagation, ctxt->err must be freed separately */
static void parser_context_free(JSONParserContext *ctxt)
{
    int i;
    if (ctxt) {
        for (i = 0; i < ctxt->tokens.count; i++) {
            qobject_decref(ctxt->tokens.buf[i]);
        }
        g_free(ctxt->tokens.buf);
        g_free(ctxt);
    }
}

/**
 * Parsing rules
 */
static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
{
    QObject *key = NULL, *token = NULL, *value, *peek;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    peek = parser_context_peek_token(ctxt);
    if (peek == NULL) {
        parse_error(ctxt, NULL, "premature EOI");
        goto out;
    }

    key = parse_value(ctxt, ap);
    if (!key || qobject_type(key) != QTYPE_QSTRING) {
        parse_error(ctxt, peek, "key is not a string in object");
        goto out;
    }

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        parse_error(ctxt, NULL, "premature EOI");
        goto out;
    }

    if (!token_is_operator(token, ':')) {
        parse_error(ctxt, token, "missing : in object pair");
        goto out;
    }

    value = parse_value(ctxt, ap);
    if (value == NULL) {
        parse_error(ctxt, token, "Missing value in dict");
        goto out;
    }

    qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);

    qobject_decref(key);

    return 0;

out:
    parser_context_restore(ctxt, saved_ctxt);
    qobject_decref(key);

    return -1;
}

static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
{
    QDict *dict = NULL;
    QObject *token, *peek;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        goto out;
    }

    if (!token_is_operator(token, '{')) {
        goto out;
    }

    dict = qdict_new();

    peek = parser_context_peek_token(ctxt);
    if (peek == NULL) {
        parse_error(ctxt, NULL, "premature EOI");
        goto out;
    }

    if (!token_is_operator(peek, '}')) {
        if (parse_pair(ctxt, dict, ap) == -1) {
            goto out;
        }

        token = parser_context_pop_token(ctxt);
        if (token == NULL) {
            parse_error(ctxt, NULL, "premature EOI");
            goto out;
        }

        while (!token_is_operator(token, '}')) {
            if (!token_is_operator(token, ',')) {
                parse_error(ctxt, token, "expected separator in dict");
                goto out;
            }

            if (parse_pair(ctxt, dict, ap) == -1) {
                goto out;
            }

            token = parser_context_pop_token(ctxt);
            if (token == NULL) {
                parse_error(ctxt, NULL, "premature EOI");
                goto out;
            }
        }
    } else {
        (void)parser_context_pop_token(ctxt);
    }

    return QOBJECT(dict);

out:
    parser_context_restore(ctxt, saved_ctxt);
    QDECREF(dict);
    return NULL;
}

static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
{
    QList *list = NULL;
    QObject *token, *peek;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        goto out;
    }

    if (!token_is_operator(token, '[')) {
        goto out;
    }

    list = qlist_new();

    peek = parser_context_peek_token(ctxt);
    if (peek == NULL) {
        parse_error(ctxt, NULL, "premature EOI");
        goto out;
    }

    if (!token_is_operator(peek, ']')) {
        QObject *obj;

        obj = parse_value(ctxt, ap);
        if (obj == NULL) {
            parse_error(ctxt, token, "expecting value");
            goto out;
        }

        qlist_append_obj(list, obj);

        token = parser_context_pop_token(ctxt);
        if (token == NULL) {
            parse_error(ctxt, NULL, "premature EOI");
            goto out;
        }

        while (!token_is_operator(token, ']')) {
            if (!token_is_operator(token, ',')) {
                parse_error(ctxt, token, "expected separator in list");
                goto out;
            }

            obj = parse_value(ctxt, ap);
            if (obj == NULL) {
                parse_error(ctxt, token, "expecting value");
                goto out;
            }

            qlist_append_obj(list, obj);

            token = parser_context_pop_token(ctxt);
            if (token == NULL) {
                parse_error(ctxt, NULL, "premature EOI");
                goto out;
            }
        }
    } else {
        (void)parser_context_pop_token(ctxt);
    }

    return QOBJECT(list);

out:
    parser_context_restore(ctxt, saved_ctxt);
    QDECREF(list);
    return NULL;
}

static QObject *parse_keyword(JSONParserContext *ctxt)
{
    QObject *token, *ret;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        goto out;
    }

    if (token_get_type(token) != JSON_KEYWORD) {
        goto out;
    }

    if (token_is_keyword(token, "true")) {
        ret = QOBJECT(qbool_from_bool(true));
    } else if (token_is_keyword(token, "false")) {
        ret = QOBJECT(qbool_from_bool(false));
    } else if (token_is_keyword(token, "null")) {
        ret = qnull();
    } else {
        parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
        goto out;
    }

    return ret;

out: 
    parser_context_restore(ctxt, saved_ctxt);

    return NULL;
}

static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap)
{
    QObject *token = NULL, *obj;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    if (ap == NULL) {
        goto out;
    }

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        goto out;
    }

    if (token_is_escape(token, "%p")) {
        obj = va_arg(*ap, QObject *);
    } else if (token_is_escape(token, "%i")) {
        obj = QOBJECT(qbool_from_bool(va_arg(*ap, int)));
    } else if (token_is_escape(token, "%d")) {
        obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
    } else if (token_is_escape(token, "%ld")) {
        obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
    } else if (token_is_escape(token, "%lld") ||
               token_is_escape(token, "%I64d")) {
        obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
    } else if (token_is_escape(token, "%s")) {
        obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
    } else if (token_is_escape(token, "%f")) {
        obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
    } else {
        goto out;
    }

    return obj;

out:
    parser_context_restore(ctxt, saved_ctxt);

    return NULL;
}

static QObject *parse_literal(JSONParserContext *ctxt)
{
    QObject *token, *obj;
    JSONParserContext saved_ctxt = parser_context_save(ctxt);

    token = parser_context_pop_token(ctxt);
    if (token == NULL) {
        goto out;
    }

    switch (token_get_type(token)) {
    case JSON_STRING:
        obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
        break;
    case JSON_INTEGER: {
        /* A possibility exists that this is a whole-valued float where the
         * fractional part was left out due to being 0 (.0). It's not a big
         * deal to treat these as ints in the parser, so long as users of the
         * resulting QObject know to expect a QInt in place of a QFloat in
         * cases like these.
         *
         * However, in some cases these values will overflow/underflow a
         * QInt/int64 container, thus we should assume these are to be handled
         * as QFloats/doubles rather than silently changing their values.
         *
         * strtoll() indicates these instances by setting errno to ERANGE
         */
        int64_t value;

        errno = 0; /* strtoll doesn't set errno on success */
        value = strtoll(token_get_value(token), NULL, 10);
        if (errno != ERANGE) {
            obj = QOBJECT(qint_from_int(value));
            break;
        }
        /* fall through to JSON_FLOAT */
    }
    case JSON_FLOAT:
        /* FIXME dependent on locale */
        obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
        break;
    default:
        goto out;
    }

    return obj;

out:
    parser_context_restore(ctxt, saved_ctxt);

    return NULL;
}

static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
{
    QObject *obj;

    obj = parse_object(ctxt, ap);
    if (obj == NULL) {
        obj = parse_array(ctxt, ap);
    }
    if (obj == NULL) {
        obj = parse_escape(ctxt, ap);
    }
    if (obj == NULL) {
        obj = parse_keyword(ctxt);
    } 
    if (obj == NULL) {
        obj = parse_literal(ctxt);
    }

    return obj;
}

QObject *json_parser_parse(QList *tokens, va_list *ap)
{
    return json_parser_parse_err(tokens, ap, NULL);
}

QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp)
{
    JSONParserContext *ctxt = parser_context_new(tokens);
    QObject *result;

    if (!ctxt) {
        return NULL;
    }

    result = parse_value(ctxt, ap);

    error_propagate(errp, ctxt->err);

    parser_context_free(ctxt);

    return result;
}
Commit	Line	Data
4a5fcab7 AL	1	/*
	2	* JSON Parser
	3	*
	4	* Copyright IBM, Corp. 2009
	5	*
	6	* Authors:
	7	* Anthony Liguori <[email protected]>
	8	*
	9	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	10	* See the COPYING.LIB file in the top-level directory.
	11	*
	12	*/
	13
c96c84a9	14	#include <stdarg.h>
4a5fcab7 AL	15
4a5fcab7 AL	16	#include "qemu-common.h"
7b1b5d19 PB	17	#include "qapi/qmp/qstring.h"
	18	#include "qapi/qmp/qint.h"
	19	#include "qapi/qmp/qdict.h"
	20	#include "qapi/qmp/qlist.h"
	21	#include "qapi/qmp/qfloat.h"
	22	#include "qapi/qmp/qbool.h"
	23	#include "qapi/qmp/json-parser.h"
	24	#include "qapi/qmp/json-lexer.h"
4a5fcab7 AL	25
	26	typedef struct JSONParserContext
	27	{
ef749d07	28	Error *err;
65c0f1e9 MR	29	struct {
	30	QObject **buf;
	31	size_t pos;
	32	size_t count;
	33	} tokens;
4a5fcab7 AL	34	} JSONParserContext;
	35
	36	#define BUG_ON(cond) assert(!(cond))
	37
	38	/**
	39	* TODO
	40	*
	41	* 0) make errors meaningful again
	42	* 1) add geometry information to tokens
	43	* 3) should we return a parsed size?
	44	* 4) deal with premature EOI
	45	*/
	46
65c0f1e9	47	static QObject parse_value(JSONParserContext ctxt, va_list *ap);
4a5fcab7 AL	48
	49	/**
	50	* Token manipulators
	51	*
	52	* tokens are dictionaries that contain a type, a string value, and geometry information
	53	* about a token identified by the lexer. These are routines that make working with
	54	* these objects a bit easier.
	55	*/
	56	static const char token_get_value(QObject obj)
	57	{
	58	return qdict_get_str(qobject_to_qdict(obj), "token");
	59	}
	60
	61	static JSONTokenType token_get_type(QObject *obj)
	62	{
	63	return qdict_get_int(qobject_to_qdict(obj), "type");
	64	}
	65
	66	static int token_is_operator(QObject *obj, char op)
	67	{
	68	const char *val;
	69
	70	if (token_get_type(obj) != JSON_OPERATOR) {
	71	return 0;
	72	}
	73
	74	val = token_get_value(obj);
	75
	76	return (val[0] == op) && (val[1] == 0);
	77	}
	78
	79	static int token_is_keyword(QObject obj, const char value)
	80	{
	81	if (token_get_type(obj) != JSON_KEYWORD) {
	82	return 0;
	83	}
	84
	85	return strcmp(token_get_value(obj), value) == 0;
	86	}
	87
	88	static int token_is_escape(QObject obj, const char value)
	89	{
	90	if (token_get_type(obj) != JSON_ESCAPE) {
	91	return 0;
	92	}
	93
	94	return (strcmp(token_get_value(obj), value) == 0);
	95	}
	96
	97	/**
	98	* Error handler
	99	*/
8b7968f7 SW	100	static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
8b7968f7 SW	101	QObject token, const char msg, ...)
4a5fcab7	102	{
c96c84a9	103	va_list ap;
ef749d07	104	char message[1024];
c96c84a9	105	va_start(ap, msg);
ef749d07	106	vsnprintf(message, sizeof(message), msg, ap);
c96c84a9	107	va_end(ap);
ef749d07 AL	108	if (ctxt->err) {
	109	error_free(ctxt->err);
	110	ctxt->err = NULL;
	111	}
f231b88d	112	error_setg(&ctxt->err, "JSON parse error, %s", message);
4a5fcab7 AL	113	}
	114
	115	/**
	116	* String helpers
	117	*
	118	* These helpers are used to unescape strings.
	119	*/
	120	static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
	121	{
	122	if (wchar <= 0x007F) {
	123	BUG_ON(buffer_length < 2);
	124
	125	buffer[0] = wchar & 0x7F;
	126	buffer[1] = 0;
	127	} else if (wchar <= 0x07FF) {
	128	BUG_ON(buffer_length < 3);
	129
	130	buffer[0] = 0xC0 \| ((wchar >> 6) & 0x1F);
	131	buffer[1] = 0x80 \| (wchar & 0x3F);
	132	buffer[2] = 0;
	133	} else {
	134	BUG_ON(buffer_length < 4);
	135
	136	buffer[0] = 0xE0 \| ((wchar >> 12) & 0x0F);
	137	buffer[1] = 0x80 \| ((wchar >> 6) & 0x3F);
	138	buffer[2] = 0x80 \| (wchar & 0x3F);
	139	buffer[3] = 0;
	140	}
	141	}
	142
	143	static int hex2decimal(char ch)
	144	{
	145	if (ch >= '0' && ch <= '9') {
	146	return (ch - '0');
	147	} else if (ch >= 'a' && ch <= 'f') {
	148	return 10 + (ch - 'a');
	149	} else if (ch >= 'A' && ch <= 'F') {
	150	return 10 + (ch - 'A');
	151	}
	152
	153	return -1;
	154	}
	155
	156	/**
	157	* parse_string(): Parse a json string and return a QObject
	158	*
	159	* string
	160	* ""
	161	* " chars "
	162	* chars
	163	* char
	164	* char chars
	165	* char
	166	* any-Unicode-character-
	167	* except-"-or-\-or-
	168	* control-character
	169	* \"
	170	* \\
	171	* \/
	172	* \b
	173	* \f
	174	* \n
	175	* \r
	176	* \t
177	* \u four-hex-digits
178	*/
179	static QString qstring_from_escaped_str(JSONParserContext ctxt, QObject *token)
180	{
181	const char *ptr = token_get_value(token);
182	QString *str;
183	int double_quote = 1;
184
185	if (*ptr == '"') {
186	double_quote = 1;
187	} else {
188	double_quote = 0;
189	}
190	ptr++;
191
192	str = qstring_new();
193	while (*ptr &&
194	((double_quote && ptr != '"') \|\| (!double_quote && ptr != '\''))) {
195	if (*ptr == '\\') {
196	ptr++;
197
198	switch (*ptr) {
199	case '"':
200	qstring_append(str, "\"");
201	ptr++;
202	break;
203	case '\'':
204	qstring_append(str, "'");
205	ptr++;
206	break;
207	case '\\':
208	qstring_append(str, "\\");
209	ptr++;
210	break;
211	case '/':
212	qstring_append(str, "/");
213	ptr++;
214	break;
215	case 'b':
216	qstring_append(str, "\b");
217	ptr++;
218	break;
bd032695 LC	219	case 'f':
	220	qstring_append(str, "\f");
	221	ptr++;
	222	break;
4a5fcab7 AL	223	case 'n':
	224	qstring_append(str, "\n");
	225	ptr++;
	226	break;
	227	case 'r':
	228	qstring_append(str, "\r");
	229	ptr++;
	230	break;
	231	case 't':
	232	qstring_append(str, "\t");
	233	ptr++;
	234	break;
	235	case 'u': {
	236	uint16_t unicode_char = 0;
	237	char utf8_char[4];
	238	int i = 0;
	239
	240	ptr++;
	241
	242	for (i = 0; i < 4; i++) {
	243	if (qemu_isxdigit(*ptr)) {
	244	unicode_char \|= hex2decimal(ptr) << ((3 - i) 4);
	245	} else {
	246	parse_error(ctxt, token,
	247	"invalid hex escape sequence in string");
	248	goto out;
	249	}
	250	ptr++;
	251	}
	252
	253	wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
	254	qstring_append(str, utf8_char);
	255	} break;
	256	default:
	257	parse_error(ctxt, token, "invalid escape sequence in string");
	258	goto out;
	259	}
	260	} else {
	261	char dummy[2];
	262
	263	dummy[0] = *ptr++;
	264	dummy[1] = 0;
	265
	266	qstring_append(str, dummy);
	267	}
	268	}
	269
4a5fcab7 AL	270	return str;
	271
	272	out:
	273	QDECREF(str);
	274	return NULL;
	275	}
	276
65c0f1e9 MR	277	static QObject parser_context_pop_token(JSONParserContext ctxt)
	278	{
	279	QObject *token;
	280	g_assert(ctxt->tokens.pos < ctxt->tokens.count);
	281	token = ctxt->tokens.buf[ctxt->tokens.pos];
	282	ctxt->tokens.pos++;
	283	return token;
	284	}
	285
	286	/* Note: parser_context_{peek\|pop}_token do not increment the
	287	* token object's refcount. In both cases the references will continue
	288	* to be tracked and cleaned up in parser_context_free(), so do not
	289	* attempt to free the token object.
	290	*/
	291	static QObject parser_context_peek_token(JSONParserContext ctxt)
	292	{
	293	QObject *token;
	294	g_assert(ctxt->tokens.pos < ctxt->tokens.count);
	295	token = ctxt->tokens.buf[ctxt->tokens.pos];
	296	return token;
	297	}
	298
	299	static JSONParserContext parser_context_save(JSONParserContext *ctxt)
	300	{
	301	JSONParserContext saved_ctxt = {0};
	302	saved_ctxt.tokens.pos = ctxt->tokens.pos;
	303	saved_ctxt.tokens.count = ctxt->tokens.count;
	304	saved_ctxt.tokens.buf = ctxt->tokens.buf;
	305	return saved_ctxt;
	306	}
	307
	308	static void parser_context_restore(JSONParserContext *ctxt,
	309	JSONParserContext saved_ctxt)
	310	{
	311	ctxt->tokens.pos = saved_ctxt.tokens.pos;
	312	ctxt->tokens.count = saved_ctxt.tokens.count;
	313	ctxt->tokens.buf = saved_ctxt.tokens.buf;
	314	}
	315
	316	static void tokens_append_from_iter(QObject obj, void opaque)
	317	{
	318	JSONParserContext *ctxt = opaque;
	319	g_assert(ctxt->tokens.pos < ctxt->tokens.count);
	320	ctxt->tokens.buf[ctxt->tokens.pos++] = obj;
	321	qobject_incref(obj);
	322	}
	323
	324	static JSONParserContext parser_context_new(QList tokens)
	325	{
	326	JSONParserContext *ctxt;
	327	size_t count;
	328
	329	if (!tokens) {
	330	return NULL;
	331	}
	332
	333	count = qlist_size(tokens);
	334	if (count == 0) {
	335	return NULL;
	336	}
	337
	338	ctxt = g_malloc0(sizeof(JSONParserContext));
	339	ctxt->tokens.pos = 0;
	340	ctxt->tokens.count = count;
341	ctxt->tokens.buf = g_malloc(count * sizeof(QObject *));
342	qlist_iter(tokens, tokens_append_from_iter, ctxt);
343	ctxt->tokens.pos = 0;
344
345	return ctxt;
346	}
347
348	/* to support error propagation, ctxt->err must be freed separately */
349	static void parser_context_free(JSONParserContext *ctxt)
350	{
351	int i;
352	if (ctxt) {
353	for (i = 0; i < ctxt->tokens.count; i++) {
354	qobject_decref(ctxt->tokens.buf[i]);
355	}
356	g_free(ctxt->tokens.buf);
357	g_free(ctxt);
358	}
359	}
360
4a5fcab7 AL	361	/**
	362	* Parsing rules
	363	*/
65c0f1e9	364	static int parse_pair(JSONParserContext ctxt, QDict dict, va_list *ap)
4a5fcab7	365	{
11e8a46c	366	QObject key = NULL, token = NULL, value, peek;
65c0f1e9	367	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7	368
65c0f1e9	369	peek = parser_context_peek_token(ctxt);
11e8a46c AL	370	if (peek == NULL) {
	371	parse_error(ctxt, NULL, "premature EOI");
	372	goto out;
	373	}
	374
65c0f1e9	375	key = parse_value(ctxt, ap);
d758d90f	376	if (!key \|\| qobject_type(key) != QTYPE_QSTRING) {
4a5fcab7 AL	377	parse_error(ctxt, peek, "key is not a string in object");
	378	goto out;
	379	}
	380
65c0f1e9	381	token = parser_context_pop_token(ctxt);
11e8a46c AL	382	if (token == NULL) {
	383	parse_error(ctxt, NULL, "premature EOI");
	384	goto out;
	385	}
	386
4a5fcab7 AL	387	if (!token_is_operator(token, ':')) {
	388	parse_error(ctxt, token, "missing : in object pair");
	389	goto out;
	390	}
	391
65c0f1e9	392	value = parse_value(ctxt, ap);
4a5fcab7 AL	393	if (value == NULL) {
	394	parse_error(ctxt, token, "Missing value in dict");
	395	goto out;
	396	}
	397
	398	qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
	399
4a5fcab7	400	qobject_decref(key);
4a5fcab7 AL	401
	402	return 0;
	403
	404	out:
65c0f1e9	405	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7	406	qobject_decref(key);
4a5fcab7 AL	407
	408	return -1;
	409	}
	410
65c0f1e9	411	static QObject parse_object(JSONParserContext ctxt, va_list *ap)
4a5fcab7 AL	412	{
	413	QDict *dict = NULL;
	414	QObject token, peek;
65c0f1e9	415	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7	416
65c0f1e9	417	token = parser_context_pop_token(ctxt);
11e8a46c AL	418	if (token == NULL) {
	419	goto out;
	420	}
	421
4a5fcab7 AL	422	if (!token_is_operator(token, '{')) {
	423	goto out;
	424	}
4a5fcab7 AL	425
	426	dict = qdict_new();
	427
65c0f1e9	428	peek = parser_context_peek_token(ctxt);
11e8a46c AL	429	if (peek == NULL) {
	430	parse_error(ctxt, NULL, "premature EOI");
	431	goto out;
	432	}
	433
4a5fcab7	434	if (!token_is_operator(peek, '}')) {
65c0f1e9	435	if (parse_pair(ctxt, dict, ap) == -1) {
4a5fcab7 AL	436	goto out;
	437	}
	438
65c0f1e9	439	token = parser_context_pop_token(ctxt);
11e8a46c AL	440	if (token == NULL) {
	441	parse_error(ctxt, NULL, "premature EOI");
	442	goto out;
	443	}
	444
4a5fcab7 AL	445	while (!token_is_operator(token, '}')) {
	446	if (!token_is_operator(token, ',')) {
	447	parse_error(ctxt, token, "expected separator in dict");
	448	goto out;
	449	}
4a5fcab7	450
65c0f1e9	451	if (parse_pair(ctxt, dict, ap) == -1) {
4a5fcab7 AL	452	goto out;
	453	}
	454
65c0f1e9	455	token = parser_context_pop_token(ctxt);
11e8a46c AL	456	if (token == NULL) {
	457	parse_error(ctxt, NULL, "premature EOI");
	458	goto out;
	459	}
4a5fcab7	460	}
4a5fcab7	461	} else {
a491af47	462	(void)parser_context_pop_token(ctxt);
4a5fcab7 AL	463	}
4a5fcab7 AL	464
4a5fcab7 AL	465	return QOBJECT(dict);
	466
	467	out:
65c0f1e9	468	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7 AL	469	QDECREF(dict);
	470	return NULL;
	471	}
	472
65c0f1e9	473	static QObject parse_array(JSONParserContext ctxt, va_list *ap)
4a5fcab7 AL	474	{
	475	QList *list = NULL;
	476	QObject token, peek;
65c0f1e9	477	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7	478
65c0f1e9	479	token = parser_context_pop_token(ctxt);
11e8a46c AL	480	if (token == NULL) {
	481	goto out;
	482	}
	483
4a5fcab7 AL	484	if (!token_is_operator(token, '[')) {
	485	goto out;
	486	}
4a5fcab7 AL	487
	488	list = qlist_new();
	489
65c0f1e9	490	peek = parser_context_peek_token(ctxt);
11e8a46c AL	491	if (peek == NULL) {
	492	parse_error(ctxt, NULL, "premature EOI");
	493	goto out;
	494	}
	495
4a5fcab7 AL	496	if (!token_is_operator(peek, ']')) {
	497	QObject *obj;
	498
65c0f1e9	499	obj = parse_value(ctxt, ap);
4a5fcab7 AL	500	if (obj == NULL) {
	501	parse_error(ctxt, token, "expecting value");
	502	goto out;
	503	}
	504
	505	qlist_append_obj(list, obj);
	506
65c0f1e9	507	token = parser_context_pop_token(ctxt);
11e8a46c AL	508	if (token == NULL) {
	509	parse_error(ctxt, NULL, "premature EOI");
	510	goto out;
	511	}
	512
4a5fcab7 AL	513	while (!token_is_operator(token, ']')) {
	514	if (!token_is_operator(token, ',')) {
	515	parse_error(ctxt, token, "expected separator in list");
	516	goto out;
	517	}
	518
65c0f1e9	519	obj = parse_value(ctxt, ap);
4a5fcab7 AL	520	if (obj == NULL) {
	521	parse_error(ctxt, token, "expecting value");
	522	goto out;
	523	}
	524
	525	qlist_append_obj(list, obj);
	526
65c0f1e9	527	token = parser_context_pop_token(ctxt);
11e8a46c AL	528	if (token == NULL) {
	529	parse_error(ctxt, NULL, "premature EOI");
	530	goto out;
	531	}
4a5fcab7	532	}
4a5fcab7	533	} else {
a491af47	534	(void)parser_context_pop_token(ctxt);
4a5fcab7 AL	535	}
4a5fcab7 AL	536
4a5fcab7 AL	537	return QOBJECT(list);
	538
	539	out:
65c0f1e9	540	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7 AL	541	QDECREF(list);
	542	return NULL;
	543	}
	544
65c0f1e9	545	static QObject parse_keyword(JSONParserContext ctxt)
4a5fcab7 AL	546	{
4a5fcab7 AL	547	QObject token, ret;
65c0f1e9	548	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7	549
65c0f1e9	550	token = parser_context_pop_token(ctxt);
11e8a46c AL	551	if (token == NULL) {
	552	goto out;
	553	}
4a5fcab7 AL	554
	555	if (token_get_type(token) != JSON_KEYWORD) {
	556	goto out;
	557	}
	558
	559	if (token_is_keyword(token, "true")) {
fc48ffc3	560	ret = QOBJECT(qbool_from_bool(true));
4a5fcab7	561	} else if (token_is_keyword(token, "false")) {
fc48ffc3	562	ret = QOBJECT(qbool_from_bool(false));
e549e716 EB	563	} else if (token_is_keyword(token, "null")) {
e549e716 EB	564	ret = qnull();
4a5fcab7 AL	565	} else {
	566	parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
	567	goto out;
	568	}
	569
4a5fcab7 AL	570	return ret;
	571
	572	out:
65c0f1e9	573	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7 AL	574
	575	return NULL;
	576	}
	577
65c0f1e9	578	static QObject parse_escape(JSONParserContext ctxt, va_list *ap)
4a5fcab7 AL	579	{
4a5fcab7 AL	580	QObject token = NULL, obj;
65c0f1e9	581	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7 AL	582
	583	if (ap == NULL) {
	584	goto out;
	585	}
	586
65c0f1e9	587	token = parser_context_pop_token(ctxt);
11e8a46c AL	588	if (token == NULL) {
	589	goto out;
	590	}
4a5fcab7 AL	591
	592	if (token_is_escape(token, "%p")) {
	593	obj = va_arg(ap, QObject );
	594	} else if (token_is_escape(token, "%i")) {
fc48ffc3	595	obj = QOBJECT(qbool_from_bool(va_arg(*ap, int)));
4a5fcab7 AL	596	} else if (token_is_escape(token, "%d")) {
	597	obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
	598	} else if (token_is_escape(token, "%ld")) {
	599	obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
2c0d4b36 RT	600	} else if (token_is_escape(token, "%lld") \|\|
2c0d4b36 RT	601	token_is_escape(token, "%I64d")) {
4a5fcab7 AL	602	obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
	603	} else if (token_is_escape(token, "%s")) {
	604	obj = QOBJECT(qstring_from_str(va_arg(ap, const char )));
	605	} else if (token_is_escape(token, "%f")) {
	606	obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
	607	} else {
	608	goto out;
	609	}
	610
4a5fcab7 AL	611	return obj;
	612
	613	out:
65c0f1e9	614	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7 AL	615
	616	return NULL;
	617	}
	618
65c0f1e9	619	static QObject parse_literal(JSONParserContext ctxt)
4a5fcab7 AL	620	{
4a5fcab7 AL	621	QObject token, obj;
65c0f1e9	622	JSONParserContext saved_ctxt = parser_context_save(ctxt);
4a5fcab7	623
65c0f1e9	624	token = parser_context_pop_token(ctxt);
11e8a46c AL	625	if (token == NULL) {
	626	goto out;
	627	}
	628
4a5fcab7 AL	629	switch (token_get_type(token)) {
	630	case JSON_STRING:
	631	obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
	632	break;
3d5b3ec6 MR	633	case JSON_INTEGER: {
	634	/* A possibility exists that this is a whole-valued float where the
	635	* fractional part was left out due to being 0 (.0). It's not a big
	636	* deal to treat these as ints in the parser, so long as users of the
	637	* resulting QObject know to expect a QInt in place of a QFloat in
	638	* cases like these.
	639	*
	640	* However, in some cases these values will overflow/underflow a
	641	* QInt/int64 container, thus we should assume these are to be handled
	642	* as QFloats/doubles rather than silently changing their values.
	643	*
	644	* strtoll() indicates these instances by setting errno to ERANGE
	645	*/
	646	int64_t value;
	647
	648	errno = 0; /* strtoll doesn't set errno on success */
	649	value = strtoll(token_get_value(token), NULL, 10);
	650	if (errno != ERANGE) {
	651	obj = QOBJECT(qint_from_int(value));
	652	break;
	653	}
	654	/* fall through to JSON_FLOAT */
	655	}
4a5fcab7 AL	656	case JSON_FLOAT:
	657	/* FIXME dependent on locale */
	658	obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
	659	break;
	660	default:
	661	goto out;
	662	}
	663
4a5fcab7 AL	664	return obj;
	665
	666	out:
65c0f1e9	667	parser_context_restore(ctxt, saved_ctxt);
4a5fcab7 AL	668
	669	return NULL;
	670	}
	671
65c0f1e9	672	static QObject parse_value(JSONParserContext ctxt, va_list *ap)
4a5fcab7 AL	673	{
	674	QObject *obj;
	675
65c0f1e9	676	obj = parse_object(ctxt, ap);
4a5fcab7	677	if (obj == NULL) {
65c0f1e9	678	obj = parse_array(ctxt, ap);
4a5fcab7 AL	679	}
4a5fcab7 AL	680	if (obj == NULL) {
65c0f1e9	681	obj = parse_escape(ctxt, ap);
4a5fcab7 AL	682	}
4a5fcab7 AL	683	if (obj == NULL) {
65c0f1e9	684	obj = parse_keyword(ctxt);
4a5fcab7 AL	685	}
4a5fcab7 AL	686	if (obj == NULL) {
65c0f1e9	687	obj = parse_literal(ctxt);
4a5fcab7 AL	688	}
	689
	690	return obj;
	691	}
	692
	693	QObject json_parser_parse(QList tokens, va_list *ap)
ef749d07 AL	694	{
	695	return json_parser_parse_err(tokens, ap, NULL);
	696	}
	697
	698	QObject json_parser_parse_err(QList tokens, va_list ap, Error *errp)
4a5fcab7	699	{
65c0f1e9	700	JSONParserContext *ctxt = parser_context_new(tokens);
4a5fcab7 AL	701	QObject *result;
4a5fcab7 AL	702
65c0f1e9	703	if (!ctxt) {
c1990ebf MR	704	return NULL;
c1990ebf MR	705	}
4a5fcab7	706
65c0f1e9 MR	707	result = parse_value(ctxt, ap);
	708
	709	error_propagate(errp, ctxt->err);
4a5fcab7	710
65c0f1e9	711	parser_context_free(ctxt);
ef749d07	712
4a5fcab7 AL	713	return result;
4a5fcab7 AL	714	}