hw/arm/virt: parameter passing cleanups
[qemu.git] / qapi / qobject-output-visitor.c
1 /*
2 * Core Definitions for QAPI/QMP Command Registry
3 *
4 * Copyright (C) 2012-2016 Red Hat, Inc.
5 * Copyright IBM, Corp. 2011
6 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
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
15 #include "qemu/osdep.h"
16 #include "qapi/qobject-output-visitor.h"
17 #include "qapi/visitor-impl.h"
18 #include "qemu/queue.h"
19 #include "qemu-common.h"
20 #include "qapi/qmp/types.h"
21
22 typedef struct QStackEntry {
23 QObject *value;
24 void *qapi; /* sanity check that caller uses same pointer */
25 QSLIST_ENTRY(QStackEntry) node;
26 } QStackEntry;
27
28 struct QObjectOutputVisitor {
29 Visitor visitor;
30 QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */
31 QObject *root; /* Root of the output visit */
32 QObject **result; /* User's storage location for result */
33 };
34
35 #define qobject_output_add(qov, name, value) \
36 qobject_output_add_obj(qov, name, QOBJECT(value))
37 #define qobject_output_push(qov, value, qapi) \
38 qobject_output_push_obj(qov, QOBJECT(value), qapi)
39
40 static QObjectOutputVisitor *to_qov(Visitor *v)
41 {
42 return container_of(v, QObjectOutputVisitor, visitor);
43 }
44
45 /* Push @value onto the stack of current QObjects being built */
46 static void qobject_output_push_obj(QObjectOutputVisitor *qov, QObject *value,
47 void *qapi)
48 {
49 QStackEntry *e = g_malloc0(sizeof(*e));
50
51 assert(qov->root);
52 assert(value);
53 e->value = value;
54 e->qapi = qapi;
55 QSLIST_INSERT_HEAD(&qov->stack, e, node);
56 }
57
58 /* Pop a value off the stack of QObjects being built, and return it. */
59 static QObject *qobject_output_pop(QObjectOutputVisitor *qov, void *qapi)
60 {
61 QStackEntry *e = QSLIST_FIRST(&qov->stack);
62 QObject *value;
63
64 assert(e);
65 assert(e->qapi == qapi);
66 QSLIST_REMOVE_HEAD(&qov->stack, node);
67 value = e->value;
68 assert(value);
69 g_free(e);
70 return value;
71 }
72
73 /* Add @value to the current QObject being built.
74 * If the stack is visiting a dictionary or list, @value is now owned
75 * by that container. Otherwise, @value is now the root. */
76 static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name,
77 QObject *value)
78 {
79 QStackEntry *e = QSLIST_FIRST(&qov->stack);
80 QObject *cur = e ? e->value : NULL;
81
82 if (!cur) {
83 /* Don't allow reuse of visitor on more than one root */
84 assert(!qov->root);
85 qov->root = value;
86 } else {
87 switch (qobject_type(cur)) {
88 case QTYPE_QDICT:
89 assert(name);
90 qdict_put_obj(qobject_to_qdict(cur), name, value);
91 break;
92 case QTYPE_QLIST:
93 assert(!name);
94 qlist_append_obj(qobject_to_qlist(cur), value);
95 break;
96 default:
97 g_assert_not_reached();
98 }
99 }
100 }
101
102 static void qobject_output_start_struct(Visitor *v, const char *name,
103 void **obj, size_t unused, Error **errp)
104 {
105 QObjectOutputVisitor *qov = to_qov(v);
106 QDict *dict = qdict_new();
107
108 qobject_output_add(qov, name, dict);
109 qobject_output_push(qov, dict, obj);
110 }
111
112 static void qobject_output_end_struct(Visitor *v, void **obj)
113 {
114 QObjectOutputVisitor *qov = to_qov(v);
115 QObject *value = qobject_output_pop(qov, obj);
116 assert(qobject_type(value) == QTYPE_QDICT);
117 }
118
119 static void qobject_output_start_list(Visitor *v, const char *name,
120 GenericList **listp, size_t size,
121 Error **errp)
122 {
123 QObjectOutputVisitor *qov = to_qov(v);
124 QList *list = qlist_new();
125
126 qobject_output_add(qov, name, list);
127 qobject_output_push(qov, list, listp);
128 }
129
130 static GenericList *qobject_output_next_list(Visitor *v, GenericList *tail,
131 size_t size)
132 {
133 return tail->next;
134 }
135
136 static void qobject_output_end_list(Visitor *v, void **obj)
137 {
138 QObjectOutputVisitor *qov = to_qov(v);
139 QObject *value = qobject_output_pop(qov, obj);
140 assert(qobject_type(value) == QTYPE_QLIST);
141 }
142
143 static void qobject_output_type_int64(Visitor *v, const char *name,
144 int64_t *obj, Error **errp)
145 {
146 QObjectOutputVisitor *qov = to_qov(v);
147 qobject_output_add(qov, name, qint_from_int(*obj));
148 }
149
150 static void qobject_output_type_uint64(Visitor *v, const char *name,
151 uint64_t *obj, Error **errp)
152 {
153 /* FIXME values larger than INT64_MAX become negative */
154 QObjectOutputVisitor *qov = to_qov(v);
155 qobject_output_add(qov, name, qint_from_int(*obj));
156 }
157
158 static void qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
159 Error **errp)
160 {
161 QObjectOutputVisitor *qov = to_qov(v);
162 qobject_output_add(qov, name, qbool_from_bool(*obj));
163 }
164
165 static void qobject_output_type_str(Visitor *v, const char *name, char **obj,
166 Error **errp)
167 {
168 QObjectOutputVisitor *qov = to_qov(v);
169 if (*obj) {
170 qobject_output_add(qov, name, qstring_from_str(*obj));
171 } else {
172 qobject_output_add(qov, name, qstring_from_str(""));
173 }
174 }
175
176 static void qobject_output_type_number(Visitor *v, const char *name,
177 double *obj, Error **errp)
178 {
179 QObjectOutputVisitor *qov = to_qov(v);
180 qobject_output_add(qov, name, qfloat_from_double(*obj));
181 }
182
183 static void qobject_output_type_any(Visitor *v, const char *name,
184 QObject **obj, Error **errp)
185 {
186 QObjectOutputVisitor *qov = to_qov(v);
187 qobject_incref(*obj);
188 qobject_output_add_obj(qov, name, *obj);
189 }
190
191 static void qobject_output_type_null(Visitor *v, const char *name, Error **errp)
192 {
193 QObjectOutputVisitor *qov = to_qov(v);
194 qobject_output_add_obj(qov, name, qnull());
195 }
196
197 /* Finish building, and return the root object.
198 * The root object is never null. The caller becomes the object's
199 * owner, and should use qobject_decref() when done with it. */
200 static void qobject_output_complete(Visitor *v, void *opaque)
201 {
202 QObjectOutputVisitor *qov = to_qov(v);
203
204 /* A visit must have occurred, with each start paired with end. */
205 assert(qov->root && QSLIST_EMPTY(&qov->stack));
206 assert(opaque == qov->result);
207
208 qobject_incref(qov->root);
209 *qov->result = qov->root;
210 qov->result = NULL;
211 }
212
213 static void qobject_output_free(Visitor *v)
214 {
215 QObjectOutputVisitor *qov = to_qov(v);
216 QStackEntry *e;
217
218 while (!QSLIST_EMPTY(&qov->stack)) {
219 e = QSLIST_FIRST(&qov->stack);
220 QSLIST_REMOVE_HEAD(&qov->stack, node);
221 g_free(e);
222 }
223
224 qobject_decref(qov->root);
225 g_free(qov);
226 }
227
228 Visitor *qobject_output_visitor_new(QObject **result)
229 {
230 QObjectOutputVisitor *v;
231
232 v = g_malloc0(sizeof(*v));
233
234 v->visitor.type = VISITOR_OUTPUT;
235 v->visitor.start_struct = qobject_output_start_struct;
236 v->visitor.end_struct = qobject_output_end_struct;
237 v->visitor.start_list = qobject_output_start_list;
238 v->visitor.next_list = qobject_output_next_list;
239 v->visitor.end_list = qobject_output_end_list;
240 v->visitor.type_int64 = qobject_output_type_int64;
241 v->visitor.type_uint64 = qobject_output_type_uint64;
242 v->visitor.type_bool = qobject_output_type_bool;
243 v->visitor.type_str = qobject_output_type_str;
244 v->visitor.type_number = qobject_output_type_number;
245 v->visitor.type_any = qobject_output_type_any;
246 v->visitor.type_null = qobject_output_type_null;
247 v->visitor.complete = qobject_output_complete;
248 v->visitor.free = qobject_output_free;
249
250 *result = NULL;
251 v->result = result;
252
253 return &v->visitor;
254 }