[mirror_qemu.git] / json-parser.c

/*
 * JSON Parser 
 *
 * Copyright IBM, Corp. 2009
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * 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 "qstring.h"
#include "qint.h"
#include "qdict.h"
#include "qlist.h"
#include "qfloat.h"
#include "qbool.h"
#include "json-parser.h"
#include "json-lexer.h"
#include "qerror.h"

typedef struct JSONParserContext
{
    Error *err;
} 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, QList **tokens, 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_set(&ctxt->err, QERR_JSON_PARSE_ERROR, 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;
}

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

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

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

    value = parse_value(ctxt, &working, 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(token);
    qobject_decref(key);
    QDECREF(*tokens);
    *tokens = working;

    return 0;

out:
    qobject_decref(token);
    qobject_decref(key);
    QDECREF(working);

    return -1;
}

static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
    QDict *dict = NULL;
    QObject *token, *peek;
    QList *working = qlist_copy(*tokens);

    token = qlist_pop(working);
    if (!token_is_operator(token, '{')) {
        goto out;
    }
    qobject_decref(token);
    token = NULL;

    dict = qdict_new();

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

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

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

            token = qlist_pop(working);
        }
        qobject_decref(token);
        token = NULL;
    } else {
        token = qlist_pop(working);
        qobject_decref(token);
        token = NULL;
    }

    QDECREF(*tokens);
    *tokens = working;

    return QOBJECT(dict);

out:
    qobject_decref(token);
    QDECREF(working);
    QDECREF(dict);
    return NULL;
}

static QObject *parse_array(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
    QList *list = NULL;
    QObject *token, *peek;
    QList *working = qlist_copy(*tokens);

    token = qlist_pop(working);
    if (!token_is_operator(token, '[')) {
        goto out;
    }
    qobject_decref(token);
    token = NULL;

    list = qlist_new();

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

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

        qlist_append_obj(list, obj);

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

            qobject_decref(token);
            token = NULL;

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

            qlist_append_obj(list, obj);

            token = qlist_pop(working);
        }

        qobject_decref(token);
        token = NULL;
    } else {
        token = qlist_pop(working);
        qobject_decref(token);
        token = NULL;
    }

    QDECREF(*tokens);
    *tokens = working;

    return QOBJECT(list);

out:
    qobject_decref(token);
    QDECREF(working);
    QDECREF(list);
    return NULL;
}

static QObject *parse_keyword(JSONParserContext *ctxt, QList **tokens)
{
    QObject *token, *ret;
    QList *working = qlist_copy(*tokens);

    token = qlist_pop(working);

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

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

    qobject_decref(token);
    QDECREF(*tokens);
    *tokens = working;

    return ret;

out: 
    qobject_decref(token);
    QDECREF(working);

    return NULL;
}

static QObject *parse_escape(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
    QObject *token = NULL, *obj;
    QList *working = qlist_copy(*tokens);

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

    token = qlist_pop(working);

    if (token_is_escape(token, "%p")) {
        obj = va_arg(*ap, QObject *);
    } else if (token_is_escape(token, "%i")) {
        obj = QOBJECT(qbool_from_int(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;
    }

    qobject_decref(token);
    QDECREF(*tokens);
    *tokens = working;

    return obj;

out:
    qobject_decref(token);
    QDECREF(working);

    return NULL;
}

static QObject *parse_literal(JSONParserContext *ctxt, QList **tokens)
{
    QObject *token, *obj;
    QList *working = qlist_copy(*tokens);

    token = qlist_pop(working);
    switch (token_get_type(token)) {
    case JSON_STRING:
        obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
        break;
    case JSON_INTEGER:
        obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10)));
        break;
    case JSON_FLOAT:
        /* FIXME dependent on locale */
        obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
        break;
    default:
        goto out;
    }

    qobject_decref(token);
    QDECREF(*tokens);
    *tokens = working;

    return obj;

out:
    qobject_decref(token);
    QDECREF(working);

    return NULL;
}

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

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

    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 = {};
    QList *working = qlist_copy(tokens);
    QObject *result;

    result = parse_value(&ctxt, &working, ap);

    QDECREF(working);

    error_propagate(errp, ctxt.err);

    return result;
}
Commit	Line	Data
4a5fcab7 AL	1	/*
	2	* JSON Parser
	3	*
	4	* Copyright IBM, Corp. 2009
	5	*
	6	* Authors:
	7	* Anthony Liguori <aliguori@us.ibm.com>
	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
	16	#include "qemu-common.h"
	17	#include "qstring.h"
	18	#include "qint.h"
	19	#include "qdict.h"
	20	#include "qlist.h"
	21	#include "qfloat.h"
	22	#include "qbool.h"
	23	#include "json-parser.h"
	24	#include "json-lexer.h"
ef749d07	25	#include "qerror.h"
4a5fcab7 AL	26
	27	typedef struct JSONParserContext
	28	{
ef749d07	29	Error *err;
4a5fcab7 AL	30	} JSONParserContext;
	31
	32	#define BUG_ON(cond) assert(!(cond))
	33
	34	/**
	35	* TODO
	36	*
	37	* 0) make errors meaningful again
	38	* 1) add geometry information to tokens
	39	* 3) should we return a parsed size?
	40	* 4) deal with premature EOI
	41	*/
	42
	43	static QObject parse_value(JSONParserContext ctxt, QList *tokens, va_list ap);
	44
	45	/**
	46	* Token manipulators
	47	*
	48	* tokens are dictionaries that contain a type, a string value, and geometry information
	49	* about a token identified by the lexer. These are routines that make working with
	50	* these objects a bit easier.
	51	*/
	52	static const char token_get_value(QObject obj)
	53	{
	54	return qdict_get_str(qobject_to_qdict(obj), "token");
	55	}
	56
	57	static JSONTokenType token_get_type(QObject *obj)
	58	{
	59	return qdict_get_int(qobject_to_qdict(obj), "type");
	60	}
	61
	62	static int token_is_operator(QObject *obj, char op)
	63	{
	64	const char *val;
	65
	66	if (token_get_type(obj) != JSON_OPERATOR) {
	67	return 0;
	68	}
	69
	70	val = token_get_value(obj);
	71
	72	return (val[0] == op) && (val[1] == 0);
	73	}
	74
	75	static int token_is_keyword(QObject obj, const char value)
	76	{
	77	if (token_get_type(obj) != JSON_KEYWORD) {
	78	return 0;
	79	}
	80
	81	return strcmp(token_get_value(obj), value) == 0;
	82	}
	83
	84	static int token_is_escape(QObject obj, const char value)
	85	{
	86	if (token_get_type(obj) != JSON_ESCAPE) {
	87	return 0;
	88	}
	89
	90	return (strcmp(token_get_value(obj), value) == 0);
	91	}
	92
	93	/**
94	* Error handler
95	*/
8b7968f7 SW	96	static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
8b7968f7 SW	97	QObject token, const char msg, ...)
4a5fcab7	98	{
c96c84a9	99	va_list ap;
ef749d07	100	char message[1024];
c96c84a9	101	va_start(ap, msg);
ef749d07	102	vsnprintf(message, sizeof(message), msg, ap);
c96c84a9	103	va_end(ap);
ef749d07 AL	104	if (ctxt->err) {
	105	error_free(ctxt->err);
	106	ctxt->err = NULL;
	107	}
	108	error_set(&ctxt->err, QERR_JSON_PARSE_ERROR, message);
4a5fcab7 AL	109	}
	110
	111	/**
	112	* String helpers
	113	*
	114	* These helpers are used to unescape strings.
	115	*/
	116	static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
	117	{
	118	if (wchar <= 0x007F) {
	119	BUG_ON(buffer_length < 2);
	120
	121	buffer[0] = wchar & 0x7F;
	122	buffer[1] = 0;
	123	} else if (wchar <= 0x07FF) {
	124	BUG_ON(buffer_length < 3);
	125
	126	buffer[0] = 0xC0 \| ((wchar >> 6) & 0x1F);
	127	buffer[1] = 0x80 \| (wchar & 0x3F);
	128	buffer[2] = 0;
	129	} else {
	130	BUG_ON(buffer_length < 4);
	131
	132	buffer[0] = 0xE0 \| ((wchar >> 12) & 0x0F);
	133	buffer[1] = 0x80 \| ((wchar >> 6) & 0x3F);
	134	buffer[2] = 0x80 \| (wchar & 0x3F);
	135	buffer[3] = 0;
	136	}
	137	}
	138
	139	static int hex2decimal(char ch)
	140	{
	141	if (ch >= '0' && ch <= '9') {
	142	return (ch - '0');
	143	} else if (ch >= 'a' && ch <= 'f') {
	144	return 10 + (ch - 'a');
	145	} else if (ch >= 'A' && ch <= 'F') {
	146	return 10 + (ch - 'A');
	147	}
	148
	149	return -1;
	150	}
	151
	152	/**
	153	* parse_string(): Parse a json string and return a QObject
	154	*
	155	* string
	156	* ""
	157	* " chars "
	158	* chars
	159	* char
	160	* char chars
	161	* char
	162	* any-Unicode-character-
	163	* except-"-or-\-or-
	164	* control-character
	165	* \"
	166	* \\
	167	* \/
	168	* \b
	169	* \f
	170	* \n
	171	* \r
	172	* \t
173	* \u four-hex-digits
174	*/
175	static QString qstring_from_escaped_str(JSONParserContext ctxt, QObject *token)
176	{
177	const char *ptr = token_get_value(token);
178	QString *str;
179	int double_quote = 1;
180
181	if (*ptr == '"') {
182	double_quote = 1;
183	} else {
184	double_quote = 0;
185	}
186	ptr++;
187
188	str = qstring_new();
189	while (*ptr &&
190	((double_quote && ptr != '"') \|\| (!double_quote && ptr != '\''))) {
191	if (*ptr == '\\') {
192	ptr++;
193
194	switch (*ptr) {
195	case '"':
196	qstring_append(str, "\"");
197	ptr++;
198	break;
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 'b':
212	qstring_append(str, "\b");
213	ptr++;
214	break;
bd032695 LC	215	case 'f':
	216	qstring_append(str, "\f");
	217	ptr++;
	218	break;
4a5fcab7 AL	219	case 'n':
	220	qstring_append(str, "\n");
	221	ptr++;
	222	break;
	223	case 'r':
	224	qstring_append(str, "\r");
	225	ptr++;
	226	break;
	227	case 't':
	228	qstring_append(str, "\t");
	229	ptr++;
	230	break;
	231	case 'u': {
	232	uint16_t unicode_char = 0;
	233	char utf8_char[4];
	234	int i = 0;
	235
	236	ptr++;
	237
	238	for (i = 0; i < 4; i++) {
	239	if (qemu_isxdigit(*ptr)) {
	240	unicode_char \|= hex2decimal(ptr) << ((3 - i) 4);
	241	} else {
	242	parse_error(ctxt, token,
	243	"invalid hex escape sequence in string");
	244	goto out;
	245	}
	246	ptr++;
	247	}
	248
	249	wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
	250	qstring_append(str, utf8_char);
	251	} break;
	252	default:
	253	parse_error(ctxt, token, "invalid escape sequence in string");
	254	goto out;
	255	}
	256	} else {
	257	char dummy[2];
	258
	259	dummy[0] = *ptr++;
	260	dummy[1] = 0;
	261
	262	qstring_append(str, dummy);
	263	}
	264	}
	265
4a5fcab7 AL	266	return str;
	267
	268	out:
	269	QDECREF(str);
	270	return NULL;
	271	}
	272
	273	/**
	274	* Parsing rules
	275	*/
	276	static int parse_pair(JSONParserContext ctxt, QDict dict, QList *tokens, va_list ap)
	277	{
	278	QObject key, token = NULL, value, peek;
	279	QList working = qlist_copy(tokens);
	280
	281	peek = qlist_peek(working);
	282	key = parse_value(ctxt, &working, ap);
d758d90f	283	if (!key \|\| qobject_type(key) != QTYPE_QSTRING) {
4a5fcab7 AL	284	parse_error(ctxt, peek, "key is not a string in object");
	285	goto out;
	286	}
	287
	288	token = qlist_pop(working);
	289	if (!token_is_operator(token, ':')) {
	290	parse_error(ctxt, token, "missing : in object pair");
	291	goto out;
	292	}
	293
	294	value = parse_value(ctxt, &working, ap);
	295	if (value == NULL) {
	296	parse_error(ctxt, token, "Missing value in dict");
	297	goto out;
	298	}
	299
	300	qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
	301
	302	qobject_decref(token);
	303	qobject_decref(key);
	304	QDECREF(*tokens);
	305	*tokens = working;
	306
	307	return 0;
	308
	309	out:
	310	qobject_decref(token);
	311	qobject_decref(key);
	312	QDECREF(working);
	313
	314	return -1;
	315	}
	316
	317	static QObject parse_object(JSONParserContext ctxt, QList *tokens, va_list ap)
	318	{
	319	QDict *dict = NULL;
	320	QObject token, peek;
	321	QList working = qlist_copy(tokens);
	322
	323	token = qlist_pop(working);
	324	if (!token_is_operator(token, '{')) {
	325	goto out;
	326	}
	327	qobject_decref(token);
	328	token = NULL;
	329
	330	dict = qdict_new();
	331
	332	peek = qlist_peek(working);
	333	if (!token_is_operator(peek, '}')) {
	334	if (parse_pair(ctxt, dict, &working, ap) == -1) {
	335	goto out;
	336	}
	337
	338	token = qlist_pop(working);
	339	while (!token_is_operator(token, '}')) {
	340	if (!token_is_operator(token, ',')) {
	341	parse_error(ctxt, token, "expected separator in dict");
	342	goto out;
	343	}
	344	qobject_decref(token);
	345	token = NULL;
	346
	347	if (parse_pair(ctxt, dict, &working, ap) == -1) {
348	goto out;
349	}
350
351	token = qlist_pop(working);
352	}
353	qobject_decref(token);
354	token = NULL;
355	} else {
356	token = qlist_pop(working);
357	qobject_decref(token);
358	token = NULL;
359	}
360
361	QDECREF(*tokens);
362	*tokens = working;
363
364	return QOBJECT(dict);
365
366	out:
367	qobject_decref(token);
368	QDECREF(working);
369	QDECREF(dict);
370	return NULL;
371	}
372
373	static QObject parse_array(JSONParserContext ctxt, QList *tokens, va_list ap)
374	{
375	QList *list = NULL;
376	QObject token, peek;
377	QList working = qlist_copy(tokens);
378
379	token = qlist_pop(working);
380	if (!token_is_operator(token, '[')) {
381	goto out;
382	}
383	qobject_decref(token);
384	token = NULL;
385
386	list = qlist_new();
387
388	peek = qlist_peek(working);
389	if (!token_is_operator(peek, ']')) {
390	QObject *obj;
391
392	obj = parse_value(ctxt, &working, ap);
393	if (obj == NULL) {
394	parse_error(ctxt, token, "expecting value");
395	goto out;
396	}
397
398	qlist_append_obj(list, obj);
399
400	token = qlist_pop(working);
401	while (!token_is_operator(token, ']')) {
402	if (!token_is_operator(token, ',')) {
403	parse_error(ctxt, token, "expected separator in list");
404	goto out;
405	}
406
407	qobject_decref(token);
408	token = NULL;
409
410	obj = parse_value(ctxt, &working, ap);
411	if (obj == NULL) {
412	parse_error(ctxt, token, "expecting value");
413	goto out;
414	}
415
416	qlist_append_obj(list, obj);
417
418	token = qlist_pop(working);
419	}
420
421	qobject_decref(token);
422	token = NULL;
423	} else {
424	token = qlist_pop(working);
425	qobject_decref(token);
426	token = NULL;
427	}
428
429	QDECREF(*tokens);
430	*tokens = working;
431
432	return QOBJECT(list);
433
434	out:
435	qobject_decref(token);
436	QDECREF(working);
437	QDECREF(list);
438	return NULL;
439	}
440
441	static QObject parse_keyword(JSONParserContext ctxt, QList **tokens)
442	{
443	QObject token, ret;
444	QList working = qlist_copy(tokens);
445
446	token = qlist_pop(working);
447
448	if (token_get_type(token) != JSON_KEYWORD) {
449	goto out;
450	}
451
452	if (token_is_keyword(token, "true")) {
453	ret = QOBJECT(qbool_from_int(true));
454	} else if (token_is_keyword(token, "false")) {
455	ret = QOBJECT(qbool_from_int(false));
456	} else {
457	parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
458	goto out;
459	}
460
461	qobject_decref(token);
462	QDECREF(*tokens);
463	*tokens = working;
464
465	return ret;
466
467	out:
468	qobject_decref(token);
469	QDECREF(working);
470
471	return NULL;
472	}
473
474	static QObject parse_escape(JSONParserContext ctxt, QList *tokens, va_list ap)
475	{
476	QObject token = NULL, obj;
477	QList working = qlist_copy(tokens);
478
479	if (ap == NULL) {
480	goto out;
481	}
482
483	token = qlist_pop(working);
484
485	if (token_is_escape(token, "%p")) {
486	obj = va_arg(ap, QObject );
487	} else if (token_is_escape(token, "%i")) {
488	obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));
489	} else if (token_is_escape(token, "%d")) {
490	obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
491	} else if (token_is_escape(token, "%ld")) {
492	obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
2c0d4b36 RT	493	} else if (token_is_escape(token, "%lld") \|\|
2c0d4b36 RT	494	token_is_escape(token, "%I64d")) {
4a5fcab7 AL	495	obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
	496	} else if (token_is_escape(token, "%s")) {
	497	obj = QOBJECT(qstring_from_str(va_arg(ap, const char )));
	498	} else if (token_is_escape(token, "%f")) {
	499	obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
	500	} else {
	501	goto out;
	502	}
	503
	504	qobject_decref(token);
	505	QDECREF(*tokens);
	506	*tokens = working;
	507
	508	return obj;
	509
	510	out:
	511	qobject_decref(token);
	512	QDECREF(working);
	513
	514	return NULL;
	515	}
	516
	517	static QObject parse_literal(JSONParserContext ctxt, QList **tokens)
	518	{
	519	QObject token, obj;
	520	QList working = qlist_copy(tokens);
	521
	522	token = qlist_pop(working);
	523	switch (token_get_type(token)) {
	524	case JSON_STRING:
	525	obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
	526	break;
	527	case JSON_INTEGER:
	528	obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10)));
	529	break;
	530	case JSON_FLOAT:
	531	/* FIXME dependent on locale */
	532	obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
	533	break;
	534	default:
	535	goto out;
	536	}
	537
	538	qobject_decref(token);
	539	QDECREF(*tokens);
	540	*tokens = working;
	541
	542	return obj;
	543
	544	out:
	545	qobject_decref(token);
	546	QDECREF(working);
	547
	548	return NULL;
	549	}
	550
	551	static QObject parse_value(JSONParserContext ctxt, QList *tokens, va_list ap)
	552	{
	553	QObject *obj;
	554
	555	obj = parse_object(ctxt, tokens, ap);
	556	if (obj == NULL) {
	557	obj = parse_array(ctxt, tokens, ap);
	558	}
559	if (obj == NULL) {
560	obj = parse_escape(ctxt, tokens, ap);
561	}
562	if (obj == NULL) {
563	obj = parse_keyword(ctxt, tokens);
564	}
565	if (obj == NULL) {
566	obj = parse_literal(ctxt, tokens);
567	}
568
569	return obj;
570	}
571
572	QObject json_parser_parse(QList tokens, va_list *ap)
ef749d07 AL	573	{
	574	return json_parser_parse_err(tokens, ap, NULL);
	575	}
	576
	577	QObject json_parser_parse_err(QList tokens, va_list ap, Error *errp)
4a5fcab7 AL	578	{
	579	JSONParserContext ctxt = {};
	580	QList *working = qlist_copy(tokens);
	581	QObject *result;
	582
	583	result = parse_value(&ctxt, &working, ap);
	584
	585	QDECREF(working);
	586
ef749d07 AL	587	error_propagate(errp, ctxt.err);
ef749d07 AL	588
4a5fcab7 AL	589	return result;
4a5fcab7 AL	590	}