[qemu.git] / qapi / qmp-input-visitor.c

/*
 * Input Visitor
 *
 * Copyright (C) 2012-2016 Red Hat, Inc.
 * Copyright IBM, Corp. 2011
 *
 * 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 "qemu/osdep.h"
#include "qapi/error.h"
#include "qapi/qmp-input-visitor.h"
#include "qapi/visitor-impl.h"
#include "qemu/queue.h"
#include "qemu-common.h"
#include "qapi/qmp/types.h"
#include "qapi/qmp/qerror.h"

#define QIV_STACK_SIZE 1024

typedef struct StackObject
{
    QObject *obj; /* Object being visited */

    GHashTable *h;           /* If obj is dict: unvisited keys */
    const QListEntry *entry; /* If obj is list: unvisited tail */
} StackObject;

struct QmpInputVisitor
{
    Visitor visitor;

    /* Stack of objects being visited.  stack[0] is root of visit,
     * stack[1..] records the nesting of start_struct()/end_struct()
     * and start_list()/end_list() pairs. */
    StackObject stack[QIV_STACK_SIZE];
    int nb_stack;

    /* True to reject parse in visit_end_struct() if unvisited keys remain. */
    bool strict;
};

static QmpInputVisitor *to_qiv(Visitor *v)
{
    return container_of(v, QmpInputVisitor, visitor);
}

static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
                                     const char *name,
                                     bool consume)
{
    StackObject *tos = &qiv->stack[qiv->nb_stack - 1];
    QObject *qobj = tos->obj;

    assert(qobj);

    /* If we have a name, and we're in a dictionary, then return that
     * value. */
    if (name && qobject_type(qobj) == QTYPE_QDICT) {
        if (tos->h && consume) {
            g_hash_table_remove(tos->h, name);
        }
        return qdict_get(qobject_to_qdict(qobj), name);
    }

    /* If we are in the middle of a list, then return the next element
     * of the list. */
    if (tos->entry) {
        assert(qobject_type(qobj) == QTYPE_QLIST);
        return qlist_entry_obj(tos->entry);
    }

    /* Otherwise, we are at the root of the visit or the start of a
     * list, and return the object as-is. */
    return qobj;
}

static void qdict_add_key(const char *key, QObject *obj, void *opaque)
{
    GHashTable *h = opaque;
    g_hash_table_insert(h, (gpointer) key, NULL);
}

static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
{
    GHashTable *h;
    StackObject *tos = &qiv->stack[qiv->nb_stack];

    assert(obj);
    if (qiv->nb_stack >= QIV_STACK_SIZE) {
        error_setg(errp, "An internal buffer overran");
        return;
    }

    tos->obj = obj;
    tos->entry = NULL;
    tos->h = NULL;

    if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
        h = g_hash_table_new(g_str_hash, g_str_equal);
        qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
        tos->h = h;
    }

    qiv->nb_stack++;
}


static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
{
    assert(qiv->nb_stack > 0);

    if (qiv->strict) {
        GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
        if (top_ht) {
            GHashTableIter iter;
            const char *key;

            g_hash_table_iter_init(&iter, top_ht);
            if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
                error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
            }
            g_hash_table_unref(top_ht);
        }
    }

    qiv->nb_stack--;
}

static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
                                   size_t size, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);
    Error *err = NULL;

    if (obj) {
        *obj = NULL;
    }
    if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "QDict");
        return;
    }

    qmp_input_push(qiv, qobj, &err);
    if (err) {
        error_propagate(errp, err);
        return;
    }

    if (obj) {
        *obj = g_malloc0(size);
    }
}

static void qmp_input_end_struct(Visitor *v, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, errp);
}

static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "list");
        return;
    }

    qmp_input_push(qiv, qobj, errp);
}

static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
                                        size_t size)
{
    QmpInputVisitor *qiv = to_qiv(v);
    GenericList *entry;
    StackObject *so = &qiv->stack[qiv->nb_stack - 1];
    bool first;

    if (so->entry == NULL) {
        so->entry = qlist_first(qobject_to_qlist(so->obj));
        first = true;
    } else {
        so->entry = qlist_next(so->entry);
        first = false;
    }

    if (so->entry == NULL) {
        return NULL;
    }

    entry = g_malloc0(size);
    if (first) {
        *list = entry;
    } else {
        (*list)->next = entry;
    }

    return entry;
}

static void qmp_input_end_list(Visitor *v)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, &error_abort);
}

static void qmp_input_start_alternate(Visitor *v, const char *name,
                                      GenericAlternate **obj, size_t size,
                                      bool promote_int, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, false);

    if (!qobj) {
        *obj = NULL;
        error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
        return;
    }
    *obj = g_malloc0(size);
    (*obj)->type = qobject_type(qobj);
    if (promote_int && (*obj)->type == QTYPE_QINT) {
        (*obj)->type = QTYPE_QFLOAT;
    }
}

static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
                                 Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));

    if (!qint) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "integer");
        return;
    }

    *obj = qint_get_int(qint);
}

static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                                  Error **errp)
{
    /* FIXME: qobject_to_qint mishandles values over INT64_MAX */
    QmpInputVisitor *qiv = to_qiv(v);
    QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));

    if (!qint) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "integer");
        return;
    }

    *obj = qint_get_int(qint);
}

static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
                                Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));

    if (!qbool) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "boolean");
        return;
    }

    *obj = qbool_get_bool(qbool);
}

static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));

    if (!qstr) {
        *obj = NULL;
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "string");
        return;
    }

    *obj = g_strdup(qstring_get_str(qstr));
}

static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
                                  Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);
    QInt *qint;
    QFloat *qfloat;

    qint = qobject_to_qint(qobj);
    if (qint) {
        *obj = qint_get_int(qobject_to_qint(qobj));
        return;
    }

    qfloat = qobject_to_qfloat(qobj);
    if (qfloat) {
        *obj = qfloat_get_double(qobject_to_qfloat(qobj));
        return;
    }

    error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
               "number");
}

static void qmp_input_type_any(Visitor *v, const char *name, QObject **obj,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    qobject_incref(qobj);
    *obj = qobj;
}

static void qmp_input_optional(Visitor *v, const char *name, bool *present)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    if (!qobj) {
        *present = false;
        return;
    }

    *present = true;
}

Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
{
    return &v->visitor;
}

void qmp_input_visitor_cleanup(QmpInputVisitor *v)
{
    qobject_decref(v->stack[0].obj);
    g_free(v);
}

QmpInputVisitor *qmp_input_visitor_new(QObject *obj, bool strict)
{
    QmpInputVisitor *v;

    v = g_malloc0(sizeof(*v));

    v->visitor.type = VISITOR_INPUT;
    v->visitor.start_struct = qmp_input_start_struct;
    v->visitor.end_struct = qmp_input_end_struct;
    v->visitor.start_list = qmp_input_start_list;
    v->visitor.next_list = qmp_input_next_list;
    v->visitor.end_list = qmp_input_end_list;
    v->visitor.start_alternate = qmp_input_start_alternate;
    v->visitor.type_int64 = qmp_input_type_int64;
    v->visitor.type_uint64 = qmp_input_type_uint64;
    v->visitor.type_bool = qmp_input_type_bool;
    v->visitor.type_str = qmp_input_type_str;
    v->visitor.type_number = qmp_input_type_number;
    v->visitor.type_any = qmp_input_type_any;
    v->visitor.optional = qmp_input_optional;
    v->strict = strict;

    qmp_input_push(v, obj, NULL);
    qobject_incref(obj);

    return v;
}
Commit	Line	Data
c40cc0a0 MR	1	/*
	2	* Input Visitor
	3	*
08f9541d	4	* Copyright (C) 2012-2016 Red Hat, Inc.
c40cc0a0 MR	5	* Copyright IBM, Corp. 2011
	6	*
	7	* Authors:
	8	* Anthony Liguori <[email protected]>
	9	*
	10	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	11	* See the COPYING.LIB file in the top-level directory.
	12	*
	13	*/
	14
cbf21151	15	#include "qemu/osdep.h"
da34e65c	16	#include "qapi/error.h"
7b1b5d19 PB	17	#include "qapi/qmp-input-visitor.h"
7b1b5d19 PB	18	#include "qapi/visitor-impl.h"
1de7afc9	19	#include "qemu/queue.h"
c40cc0a0	20	#include "qemu-common.h"
7b1b5d19 PB	21	#include "qapi/qmp/types.h"
7b1b5d19 PB	22	#include "qapi/qmp/qerror.h"
c40cc0a0 MR	23
	24	#define QIV_STACK_SIZE 1024
	25
	26	typedef struct StackObject
	27	{
b471d012 EB	28	QObject obj; / Object being visited */
	29
	30	GHashTable h; / If obj is dict: unvisited keys */
	31	const QListEntry entry; / If obj is list: unvisited tail */
c40cc0a0 MR	32	} StackObject;
	33
	34	struct QmpInputVisitor
	35	{
	36	Visitor visitor;
b471d012 EB	37
	38	/* Stack of objects being visited. stack[0] is root of visit,
	39	* stack[1..] records the nesting of start_struct()/end_struct()
	40	* and start_list()/end_list() pairs. */
c40cc0a0 MR	41	StackObject stack[QIV_STACK_SIZE];
c40cc0a0 MR	42	int nb_stack;
b471d012 EB	43
b471d012 EB	44	/* True to reject parse in visit_end_struct() if unvisited keys remain. */
e38ac962	45	bool strict;
c40cc0a0 MR	46	};
	47
	48	static QmpInputVisitor to_qiv(Visitor v)
	49	{
	50	return container_of(v, QmpInputVisitor, visitor);
	51	}
	52
4faaec6a	53	static QObject qmp_input_get_object(QmpInputVisitor qiv,
e8316d7e KW	54	const char *name,
e8316d7e KW	55	bool consume)
c40cc0a0	56	{
b471d012 EB	57	StackObject *tos = &qiv->stack[qiv->nb_stack - 1];
	58	QObject *qobj = tos->obj;
	59
	60	assert(qobj);
	61
	62	/* If we have a name, and we're in a dictionary, then return that
	63	* value. */
	64	if (name && qobject_type(qobj) == QTYPE_QDICT) {
	65	if (tos->h && consume) {
	66	g_hash_table_remove(tos->h, name);
47c6d3ec	67	}
b471d012 EB	68	return qdict_get(qobject_to_qdict(qobj), name);
	69	}
	70
	71	/* If we are in the middle of a list, then return the next element
	72	* of the list. */
	73	if (tos->entry) {
	74	assert(qobject_type(qobj) == QTYPE_QLIST);
	75	return qlist_entry_obj(tos->entry);
c40cc0a0 MR	76	}
c40cc0a0 MR	77
b471d012 EB	78	/* Otherwise, we are at the root of the visit or the start of a
b471d012 EB	79	* list, and return the object as-is. */
c40cc0a0 MR	80	return qobj;
	81	}
	82
e38ac962 PB	83	static void qdict_add_key(const char key, QObject obj, void *opaque)
	84	{
	85	GHashTable *h = opaque;
	86	g_hash_table_insert(h, (gpointer) key, NULL);
	87	}
	88
4faaec6a	89	static void qmp_input_push(QmpInputVisitor qiv, QObject obj, Error **errp)
c40cc0a0	90	{
e38ac962	91	GHashTable *h;
b471d012	92	StackObject *tos = &qiv->stack[qiv->nb_stack];
c40cc0a0	93
b471d012	94	assert(obj);
c40cc0a0	95	if (qiv->nb_stack >= QIV_STACK_SIZE) {
f231b88d	96	error_setg(errp, "An internal buffer overran");
c40cc0a0 MR	97	return;
c40cc0a0 MR	98	}
e38ac962	99
b471d012 EB	100	tos->obj = obj;
	101	tos->entry = NULL;
	102	tos->h = NULL;
e38ac962 PB	103
	104	if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
	105	h = g_hash_table_new(g_str_hash, g_str_equal);
	106	qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
b471d012	107	tos->h = h;
e38ac962 PB	108	}
	109
	110	qiv->nb_stack++;
c40cc0a0 MR	111	}
c40cc0a0 MR	112
57a33d89	113
c40cc0a0 MR	114	static void qmp_input_pop(QmpInputVisitor qiv, Error *errp)
c40cc0a0 MR	115	{
57a33d89	116	assert(qiv->nb_stack > 0);
e38ac962	117
57a33d89 NK	118	if (qiv->strict) {
	119	GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
	120	if (top_ht) {
f96493b1 EB	121	GHashTableIter iter;
	122	const char *key;
	123
	124	g_hash_table_iter_init(&iter, top_ht);
	125	if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
c6bd8c70	126	error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
57a33d89 NK	127	}
57a33d89 NK	128	g_hash_table_unref(top_ht);
e38ac962	129	}
e38ac962 PB	130	}
e38ac962 PB	131
c40cc0a0	132	qiv->nb_stack--;
c40cc0a0 MR	133	}
c40cc0a0 MR	134
0b2a0d6b	135	static void qmp_input_start_struct(Visitor v, const char name, void **obj,
337283df	136	size_t size, Error **errp)
c40cc0a0 MR	137	{
c40cc0a0 MR	138	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	139	QObject *qobj = qmp_input_get_object(qiv, name, true);
8b714d37	140	Error *err = NULL;
c40cc0a0	141
e58d695e EB	142	if (obj) {
	143	*obj = NULL;
	144	}
c40cc0a0	145	if (!qobj \|\| qobject_type(qobj) != QTYPE_QDICT) {
c6bd8c70 MA	146	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	147	"QDict");
c40cc0a0 MR	148	return;
	149	}
	150
8b714d37 PB	151	qmp_input_push(qiv, qobj, &err);
	152	if (err) {
	153	error_propagate(errp, err);
c40cc0a0 MR	154	return;
	155	}
	156
	157	if (obj) {
7267c094	158	*obj = g_malloc0(size);
c40cc0a0 MR	159	}
	160	}
	161
	162	static void qmp_input_end_struct(Visitor v, Error *errp)
	163	{
	164	QmpInputVisitor *qiv = to_qiv(v);
	165
	166	qmp_input_pop(qiv, errp);
	167	}
	168
	169	static void qmp_input_start_list(Visitor v, const char name, Error **errp)
	170	{
	171	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	172	QObject *qobj = qmp_input_get_object(qiv, name, true);
c40cc0a0 MR	173
c40cc0a0 MR	174	if (!qobj \|\| qobject_type(qobj) != QTYPE_QLIST) {
c6bd8c70 MA	175	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	176	"list");
c40cc0a0 MR	177	return;
	178	}
	179
	180	qmp_input_push(qiv, qobj, errp);
	181	}
	182
e65d89bf EB	183	static GenericList qmp_input_next_list(Visitor v, GenericList **list,
e65d89bf EB	184	size_t size)
c40cc0a0 MR	185	{
	186	QmpInputVisitor *qiv = to_qiv(v);
	187	GenericList *entry;
	188	StackObject *so = &qiv->stack[qiv->nb_stack - 1];
3a86a0fa PB	189	bool first;
	190
	191	if (so->entry == NULL) {
	192	so->entry = qlist_first(qobject_to_qlist(so->obj));
	193	first = true;
	194	} else {
	195	so->entry = qlist_next(so->entry);
	196	first = false;
	197	}
c40cc0a0 MR	198
	199	if (so->entry == NULL) {
	200	return NULL;
	201	}
	202
e65d89bf	203	entry = g_malloc0(size);
3a86a0fa PB	204	if (first) {
	205	*list = entry;
	206	} else {
c40cc0a0 MR	207	(*list)->next = entry;
c40cc0a0 MR	208	}
c40cc0a0 MR	209
	210	return entry;
	211	}
	212
08f9541d	213	static void qmp_input_end_list(Visitor *v)
c40cc0a0 MR	214	{
	215	QmpInputVisitor *qiv = to_qiv(v);
	216
bdd8e6b5	217	qmp_input_pop(qiv, &error_abort);
c40cc0a0 MR	218	}
c40cc0a0 MR	219
dbf11922 EB	220	static void qmp_input_start_alternate(Visitor v, const char name,
	221	GenericAlternate **obj, size_t size,
	222	bool promote_int, Error **errp)
69dd62df KW	223	{
	224	QmpInputVisitor *qiv = to_qiv(v);
	225	QObject *qobj = qmp_input_get_object(qiv, name, false);
	226
	227	if (!qobj) {
dbf11922	228	*obj = NULL;
c6bd8c70	229	error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
69dd62df KW	230	return;
69dd62df KW	231	}
dbf11922 EB	232	*obj = g_malloc0(size);
	233	(*obj)->type = qobject_type(qobj);
	234	if (promote_int && (*obj)->type == QTYPE_QINT) {
	235	(*obj)->type = QTYPE_QFLOAT;
d00341af	236	}
69dd62df KW	237	}
69dd62df KW	238
0b2a0d6b	239	static void qmp_input_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	240	Error **errp)
c40cc0a0 MR	241	{
c40cc0a0 MR	242	QmpInputVisitor *qiv = to_qiv(v);
fcf73f66	243	QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
c40cc0a0	244
fcf73f66	245	if (!qint) {
c6bd8c70 MA	246	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	247	"integer");
c40cc0a0 MR	248	return;
	249	}
	250
fcf73f66	251	*obj = qint_get_int(qint);
c40cc0a0 MR	252	}
c40cc0a0 MR	253
0b2a0d6b	254	static void qmp_input_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	255	Error **errp)
	256	{
	257	/* FIXME: qobject_to_qint mishandles values over INT64_MAX */
	258	QmpInputVisitor *qiv = to_qiv(v);
	259	QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
	260
	261	if (!qint) {
	262	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	263	"integer");
	264	return;
	265	}
	266
	267	*obj = qint_get_int(qint);
	268	}
	269
0b2a0d6b	270	static void qmp_input_type_bool(Visitor v, const char name, bool *obj,
c40cc0a0 MR	271	Error **errp)
	272	{
	273	QmpInputVisitor *qiv = to_qiv(v);
14b61600	274	QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
c40cc0a0	275
14b61600	276	if (!qbool) {
c6bd8c70 MA	277	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	278	"boolean");
c40cc0a0 MR	279	return;
	280	}
	281
14b61600	282	*obj = qbool_get_bool(qbool);
c40cc0a0 MR	283	}
c40cc0a0 MR	284
0b2a0d6b	285	static void qmp_input_type_str(Visitor v, const char name, char **obj,
c40cc0a0 MR	286	Error **errp)
	287	{
	288	QmpInputVisitor *qiv = to_qiv(v);
7f027843	289	QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
c40cc0a0	290
7f027843	291	if (!qstr) {
e58d695e	292	*obj = NULL;
c6bd8c70 MA	293	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	294	"string");
c40cc0a0 MR	295	return;
	296	}
	297
7f027843	298	*obj = g_strdup(qstring_get_str(qstr));
c40cc0a0 MR	299	}
c40cc0a0 MR	300
0b2a0d6b	301	static void qmp_input_type_number(Visitor v, const char name, double *obj,
c40cc0a0 MR	302	Error **errp)
	303	{
	304	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	305	QObject *qobj = qmp_input_get_object(qiv, name, true);
fcf73f66 MA	306	QInt *qint;
fcf73f66 MA	307	QFloat *qfloat;
c40cc0a0	308
fcf73f66 MA	309	qint = qobject_to_qint(qobj);
	310	if (qint) {
	311	*obj = qint_get_int(qobject_to_qint(qobj));
c40cc0a0 MR	312	return;
	313	}
	314
fcf73f66 MA	315	qfloat = qobject_to_qfloat(qobj);
fcf73f66 MA	316	if (qfloat) {
1ee51876	317	*obj = qfloat_get_double(qobject_to_qfloat(qobj));
fcf73f66	318	return;
1ee51876	319	}
fcf73f66 MA	320
	321	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	322	"number");
c40cc0a0 MR	323	}
c40cc0a0 MR	324
0b2a0d6b	325	static void qmp_input_type_any(Visitor v, const char name, QObject **obj,
28770e05 MA	326	Error **errp)
	327	{
	328	QmpInputVisitor *qiv = to_qiv(v);
	329	QObject *qobj = qmp_input_get_object(qiv, name, true);
	330
	331	qobject_incref(qobj);
	332	*obj = qobj;
	333	}
	334
0b2a0d6b	335	static void qmp_input_optional(Visitor v, const char name, bool *present)
c40cc0a0 MR	336	{
c40cc0a0 MR	337	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	338	QObject *qobj = qmp_input_get_object(qiv, name, true);
c40cc0a0 MR	339
	340	if (!qobj) {
	341	*present = false;
	342	return;
	343	}
	344
	345	*present = true;
	346	}
	347
c40cc0a0 MR	348	Visitor qmp_input_get_visitor(QmpInputVisitor v)
	349	{
	350	return &v->visitor;
	351	}
	352
	353	void qmp_input_visitor_cleanup(QmpInputVisitor *v)
	354	{
4faaec6a	355	qobject_decref(v->stack[0].obj);
7267c094	356	g_free(v);
c40cc0a0 MR	357	}
c40cc0a0 MR	358
fc471c18	359	QmpInputVisitor qmp_input_visitor_new(QObject obj, bool strict)
c40cc0a0 MR	360	{
	361	QmpInputVisitor *v;
	362
7267c094	363	v = g_malloc0(sizeof(*v));
c40cc0a0	364
983f52d4	365	v->visitor.type = VISITOR_INPUT;
c40cc0a0 MR	366	v->visitor.start_struct = qmp_input_start_struct;
	367	v->visitor.end_struct = qmp_input_end_struct;
	368	v->visitor.start_list = qmp_input_start_list;
	369	v->visitor.next_list = qmp_input_next_list;
	370	v->visitor.end_list = qmp_input_end_list;
dbf11922	371	v->visitor.start_alternate = qmp_input_start_alternate;
4c40314a	372	v->visitor.type_int64 = qmp_input_type_int64;
f755dea7	373	v->visitor.type_uint64 = qmp_input_type_uint64;
c40cc0a0 MR	374	v->visitor.type_bool = qmp_input_type_bool;
	375	v->visitor.type_str = qmp_input_type_str;
	376	v->visitor.type_number = qmp_input_type_number;
28770e05	377	v->visitor.type_any = qmp_input_type_any;
e2cd0f4f	378	v->visitor.optional = qmp_input_optional;
fc471c18	379	v->strict = strict;
c40cc0a0	380
4faaec6a PB	381	qmp_input_push(v, obj, NULL);
4faaec6a PB	382	qobject_incref(obj);
c40cc0a0 MR	383
	384	return v;
	385	}