[mirror_qemu.git] / qapi / qmp-output-visitor.c

/*
 * Core Definitions for QAPI/QMP Command Registry
 *
 * Copyright IBM, Corp. 2011
 *
 * 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 "qemu/osdep.h"
#include "qapi/qmp-output-visitor.h"
#include "qapi/visitor-impl.h"
#include "qemu/queue.h"
#include "qemu-common.h"
#include "qapi/qmp/types.h"

typedef struct QStackEntry
{
    QObject *value;
    bool is_list_head;
    QTAILQ_ENTRY(QStackEntry) node;
} QStackEntry;

typedef QTAILQ_HEAD(QStack, QStackEntry) QStack;

struct QmpOutputVisitor
{
    Visitor visitor;
    QStack stack;
};

#define qmp_output_add(qov, name, value) \
    qmp_output_add_obj(qov, name, QOBJECT(value))
#define qmp_output_push(qov, value) qmp_output_push_obj(qov, QOBJECT(value))

static QmpOutputVisitor *to_qov(Visitor *v)
{
    return container_of(v, QmpOutputVisitor, visitor);
}

static void qmp_output_push_obj(QmpOutputVisitor *qov, QObject *value)
{
    QStackEntry *e = g_malloc0(sizeof(*e));

    e->value = value;
    if (qobject_type(e->value) == QTYPE_QLIST) {
        e->is_list_head = true;
    }
    QTAILQ_INSERT_HEAD(&qov->stack, e, node);
}

static QObject *qmp_output_pop(QmpOutputVisitor *qov)
{
    QStackEntry *e = QTAILQ_FIRST(&qov->stack);
    QObject *value;
    QTAILQ_REMOVE(&qov->stack, e, node);
    value = e->value;
    g_free(e);
    return value;
}

static QObject *qmp_output_first(QmpOutputVisitor *qov)
{
    QStackEntry *e = QTAILQ_LAST(&qov->stack, QStack);

    /*
     * FIXME Wrong, because qmp_output_get_qobject() will increment
     * the refcnt *again*.  We need to think through how visitors
     * handle null.
     */
    if (!e) {
        return qnull();
    }

    return e->value;
}

static QObject *qmp_output_last(QmpOutputVisitor *qov)
{
    QStackEntry *e = QTAILQ_FIRST(&qov->stack);
    return e->value;
}

static void qmp_output_add_obj(QmpOutputVisitor *qov, const char *name,
                               QObject *value)
{
    QObject *cur;

    if (QTAILQ_EMPTY(&qov->stack)) {
        qmp_output_push_obj(qov, value);
        return;
    }

    cur = qmp_output_last(qov);

    switch (qobject_type(cur)) {
    case QTYPE_QDICT:
        qdict_put_obj(qobject_to_qdict(cur), name, value);
        break;
    case QTYPE_QLIST:
        qlist_append_obj(qobject_to_qlist(cur), value);
        break;
    default:
        qobject_decref(qmp_output_pop(qov));
        qmp_output_push_obj(qov, value);
        break;
    }
}

static void qmp_output_start_struct(Visitor *v, void **obj, const char *kind,
                                    const char *name, size_t unused,
                                    Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    QDict *dict = qdict_new();

    qmp_output_add(qov, name, dict);
    qmp_output_push(qov, dict);
}

static void qmp_output_end_struct(Visitor *v, Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_pop(qov);
}

static void qmp_output_start_list(Visitor *v, const char *name, Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    QList *list = qlist_new();

    qmp_output_add(qov, name, list);
    qmp_output_push(qov, list);
}

static GenericList *qmp_output_next_list(Visitor *v, GenericList **listp,
                                         Error **errp)
{
    GenericList *list = *listp;
    QmpOutputVisitor *qov = to_qov(v);
    QStackEntry *e = QTAILQ_FIRST(&qov->stack);

    assert(e);
    if (e->is_list_head) {
        e->is_list_head = false;
        return list;
    }

    return list ? list->next : NULL;
}

static void qmp_output_end_list(Visitor *v, Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_pop(qov);
}

static void qmp_output_type_int64(Visitor *v, int64_t *obj, const char *name,
                                  Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_add(qov, name, qint_from_int(*obj));
}

static void qmp_output_type_uint64(Visitor *v, uint64_t *obj, const char *name,
                                   Error **errp)
{
    /* FIXME: QMP outputs values larger than INT64_MAX as negative */
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_add(qov, name, qint_from_int(*obj));
}

static void qmp_output_type_bool(Visitor *v, bool *obj, const char *name,
                                 Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_add(qov, name, qbool_from_bool(*obj));
}

static void qmp_output_type_str(Visitor *v, char **obj, const char *name,
                                Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    if (*obj) {
        qmp_output_add(qov, name, qstring_from_str(*obj));
    } else {
        qmp_output_add(qov, name, qstring_from_str(""));
    }
}

static void qmp_output_type_number(Visitor *v, double *obj, const char *name,
                                   Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qmp_output_add(qov, name, qfloat_from_double(*obj));
}

static void qmp_output_type_any(Visitor *v, QObject **obj, const char *name,
                                Error **errp)
{
    QmpOutputVisitor *qov = to_qov(v);
    qobject_incref(*obj);
    qmp_output_add_obj(qov, name, *obj);
}

QObject *qmp_output_get_qobject(QmpOutputVisitor *qov)
{
    QObject *obj = qmp_output_first(qov);
    if (obj) {
        qobject_incref(obj);
    }
    return obj;
}

Visitor *qmp_output_get_visitor(QmpOutputVisitor *v)
{
    return &v->visitor;
}

void qmp_output_visitor_cleanup(QmpOutputVisitor *v)
{
    QStackEntry *e, *tmp;

    /* The bottom QStackEntry, if any, owns the root QObject. See the
     * qmp_output_push_obj() invocations in qmp_output_add_obj(). */
    QObject *root = QTAILQ_EMPTY(&v->stack) ? NULL : qmp_output_first(v);

    QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) {
        QTAILQ_REMOVE(&v->stack, e, node);
        g_free(e);
    }

    qobject_decref(root);
    g_free(v);
}

QmpOutputVisitor *qmp_output_visitor_new(void)
{
    QmpOutputVisitor *v;

    v = g_malloc0(sizeof(*v));

    v->visitor.start_struct = qmp_output_start_struct;
    v->visitor.end_struct = qmp_output_end_struct;
    v->visitor.start_list = qmp_output_start_list;
    v->visitor.next_list = qmp_output_next_list;
    v->visitor.end_list = qmp_output_end_list;
    v->visitor.type_enum = output_type_enum;
    v->visitor.type_int64 = qmp_output_type_int64;
    v->visitor.type_uint64 = qmp_output_type_uint64;
    v->visitor.type_bool = qmp_output_type_bool;
    v->visitor.type_str = qmp_output_type_str;
    v->visitor.type_number = qmp_output_type_number;
    v->visitor.type_any = qmp_output_type_any;

    QTAILQ_INIT(&v->stack);

    return v;
}
Commit	Line	Data
e4e6aa14 MR	1	/*
	2	* Core Definitions for QAPI/QMP Command Registry
	3	*
	4	* Copyright IBM, Corp. 2011
	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
cbf21151	14	#include "qemu/osdep.h"
7b1b5d19 PB	15	#include "qapi/qmp-output-visitor.h"
7b1b5d19 PB	16	#include "qapi/visitor-impl.h"
1de7afc9	17	#include "qemu/queue.h"
e4e6aa14	18	#include "qemu-common.h"
7b1b5d19	19	#include "qapi/qmp/types.h"
e4e6aa14 MR	20
	21	typedef struct QStackEntry
	22	{
	23	QObject *value;
e1bc2f7b	24	bool is_list_head;
e4e6aa14 MR	25	QTAILQ_ENTRY(QStackEntry) node;
	26	} QStackEntry;
	27
	28	typedef QTAILQ_HEAD(QStack, QStackEntry) QStack;
	29
	30	struct QmpOutputVisitor
	31	{
	32	Visitor visitor;
	33	QStack stack;
	34	};
	35
	36	#define qmp_output_add(qov, name, value) \
	37	qmp_output_add_obj(qov, name, QOBJECT(value))
	38	#define qmp_output_push(qov, value) qmp_output_push_obj(qov, QOBJECT(value))
	39
	40	static QmpOutputVisitor to_qov(Visitor v)
	41	{
	42	return container_of(v, QmpOutputVisitor, visitor);
	43	}
	44
	45	static void qmp_output_push_obj(QmpOutputVisitor qov, QObject value)
	46	{
7267c094	47	QStackEntry e = g_malloc0(sizeof(e));
e4e6aa14 MR	48
e4e6aa14 MR	49	e->value = value;
e1bc2f7b MR	50	if (qobject_type(e->value) == QTYPE_QLIST) {
	51	e->is_list_head = true;
	52	}
e4e6aa14 MR	53	QTAILQ_INSERT_HEAD(&qov->stack, e, node);
	54	}
	55
	56	static QObject qmp_output_pop(QmpOutputVisitor qov)
	57	{
	58	QStackEntry *e = QTAILQ_FIRST(&qov->stack);
	59	QObject *value;
	60	QTAILQ_REMOVE(&qov->stack, e, node);
	61	value = e->value;
7267c094	62	g_free(e);
e4e6aa14 MR	63	return value;
	64	}
	65
	66	static QObject qmp_output_first(QmpOutputVisitor qov)
	67	{
	68	QStackEntry *e = QTAILQ_LAST(&qov->stack, QStack);
1d10b445	69
6c2f9a15 MA	70	/*
	71	* FIXME Wrong, because qmp_output_get_qobject() will increment
	72	* the refcnt again. We need to think through how visitors
	73	* handle null.
	74	*/
1d10b445	75	if (!e) {
6c2f9a15	76	return qnull();
1d10b445 MA	77	}
1d10b445 MA	78
e4e6aa14 MR	79	return e->value;
	80	}
	81
	82	static QObject qmp_output_last(QmpOutputVisitor qov)
	83	{
	84	QStackEntry *e = QTAILQ_FIRST(&qov->stack);
	85	return e->value;
	86	}
	87
	88	static void qmp_output_add_obj(QmpOutputVisitor qov, const char name,
	89	QObject *value)
	90	{
	91	QObject *cur;
	92
	93	if (QTAILQ_EMPTY(&qov->stack)) {
	94	qmp_output_push_obj(qov, value);
	95	return;
	96	}
	97
	98	cur = qmp_output_last(qov);
	99
	100	switch (qobject_type(cur)) {
	101	case QTYPE_QDICT:
	102	qdict_put_obj(qobject_to_qdict(cur), name, value);
	103	break;
	104	case QTYPE_QLIST:
	105	qlist_append_obj(qobject_to_qlist(cur), value);
	106	break;
	107	default:
	108	qobject_decref(qmp_output_pop(qov));
	109	qmp_output_push_obj(qov, value);
	110	break;
	111	}
	112	}
	113
	114	static void qmp_output_start_struct(Visitor v, void obj, const char kind,
	115	const char *name, size_t unused,
	116	Error **errp)
	117	{
	118	QmpOutputVisitor *qov = to_qov(v);
	119	QDict *dict = qdict_new();
	120
	121	qmp_output_add(qov, name, dict);
	122	qmp_output_push(qov, dict);
	123	}
	124
	125	static void qmp_output_end_struct(Visitor v, Error *errp)
	126	{
	127	QmpOutputVisitor *qov = to_qov(v);
	128	qmp_output_pop(qov);
	129	}
	130
	131	static void qmp_output_start_list(Visitor v, const char name, Error **errp)
	132	{
	133	QmpOutputVisitor *qov = to_qov(v);
	134	QList *list = qlist_new();
	135
	136	qmp_output_add(qov, name, list);
	137	qmp_output_push(qov, list);
	138	}
	139
e1bc2f7b	140	static GenericList qmp_output_next_list(Visitor v, GenericList **listp,
e4e6aa14 MR	141	Error **errp)
e4e6aa14 MR	142	{
e1bc2f7b MR	143	GenericList list = listp;
	144	QmpOutputVisitor *qov = to_qov(v);
	145	QStackEntry *e = QTAILQ_FIRST(&qov->stack);
	146
	147	assert(e);
	148	if (e->is_list_head) {
	149	e->is_list_head = false;
	150	return list;
	151	}
	152
	153	return list ? list->next : NULL;
e4e6aa14 MR	154	}
	155
	156	static void qmp_output_end_list(Visitor v, Error *errp)
	157	{
	158	QmpOutputVisitor *qov = to_qov(v);
	159	qmp_output_pop(qov);
	160	}
	161
4c40314a EB	162	static void qmp_output_type_int64(Visitor v, int64_t obj, const char *name,
4c40314a EB	163	Error **errp)
e4e6aa14 MR	164	{
	165	QmpOutputVisitor *qov = to_qov(v);
	166	qmp_output_add(qov, name, qint_from_int(*obj));
	167	}
	168
f755dea7 EB	169	static void qmp_output_type_uint64(Visitor v, uint64_t obj, const char *name,
	170	Error **errp)
	171	{
	172	/* FIXME: QMP outputs values larger than INT64_MAX as negative */
	173	QmpOutputVisitor *qov = to_qov(v);
	174	qmp_output_add(qov, name, qint_from_int(*obj));
	175	}
	176
e4e6aa14 MR	177	static void qmp_output_type_bool(Visitor v, bool obj, const char *name,
	178	Error **errp)
	179	{
	180	QmpOutputVisitor *qov = to_qov(v);
fc48ffc3	181	qmp_output_add(qov, name, qbool_from_bool(*obj));
e4e6aa14 MR	182	}
	183
	184	static void qmp_output_type_str(Visitor v, char obj, const char name,
	185	Error **errp)
	186	{
	187	QmpOutputVisitor *qov = to_qov(v);
	188	if (*obj) {
	189	qmp_output_add(qov, name, qstring_from_str(*obj));
	190	} else {
	191	qmp_output_add(qov, name, qstring_from_str(""));
	192	}
	193	}
	194
	195	static void qmp_output_type_number(Visitor v, double obj, const char *name,
	196	Error **errp)
	197	{
	198	QmpOutputVisitor *qov = to_qov(v);
	199	qmp_output_add(qov, name, qfloat_from_double(*obj));
	200	}
	201
28770e05 MA	202	static void qmp_output_type_any(Visitor v, QObject obj, const char name,
	203	Error **errp)
	204	{
	205	QmpOutputVisitor *qov = to_qov(v);
	206	qobject_incref(*obj);
	207	qmp_output_add_obj(qov, name, *obj);
	208	}
	209
e4e6aa14 MR	210	QObject qmp_output_get_qobject(QmpOutputVisitor qov)
	211	{
	212	QObject *obj = qmp_output_first(qov);
	213	if (obj) {
	214	qobject_incref(obj);
	215	}
	216	return obj;
	217	}
	218
	219	Visitor qmp_output_get_visitor(QmpOutputVisitor v)
	220	{
	221	return &v->visitor;
	222	}
	223
	224	void qmp_output_visitor_cleanup(QmpOutputVisitor *v)
	225	{
	226	QStackEntry e, tmp;
	227
f24582d6 LE	228	/* The bottom QStackEntry, if any, owns the root QObject. See the
	229	* qmp_output_push_obj() invocations in qmp_output_add_obj(). */
	230	QObject *root = QTAILQ_EMPTY(&v->stack) ? NULL : qmp_output_first(v);
	231
e4e6aa14 MR	232	QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) {
e4e6aa14 MR	233	QTAILQ_REMOVE(&v->stack, e, node);
7267c094	234	g_free(e);
e4e6aa14 MR	235	}
e4e6aa14 MR	236
f24582d6	237	qobject_decref(root);
7267c094	238	g_free(v);
e4e6aa14 MR	239	}
	240
	241	QmpOutputVisitor *qmp_output_visitor_new(void)
	242	{
	243	QmpOutputVisitor *v;
	244
7267c094	245	v = g_malloc0(sizeof(*v));
e4e6aa14 MR	246
	247	v->visitor.start_struct = qmp_output_start_struct;
	248	v->visitor.end_struct = qmp_output_end_struct;
	249	v->visitor.start_list = qmp_output_start_list;
	250	v->visitor.next_list = qmp_output_next_list;
	251	v->visitor.end_list = qmp_output_end_list;
0f71a1e0	252	v->visitor.type_enum = output_type_enum;
4c40314a	253	v->visitor.type_int64 = qmp_output_type_int64;
f755dea7	254	v->visitor.type_uint64 = qmp_output_type_uint64;
e4e6aa14 MR	255	v->visitor.type_bool = qmp_output_type_bool;
	256	v->visitor.type_str = qmp_output_type_str;
	257	v->visitor.type_number = qmp_output_type_number;
28770e05	258	v->visitor.type_any = qmp_output_type_any;
e4e6aa14 MR	259
	260	QTAILQ_INIT(&v->stack);
	261
	262	return v;
	263	}