Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / qapi / qapi-visit-core.c
1 /*
2 * Core Definitions for QAPI Visitor Classes
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
14 #include "qemu-common.h"
15 #include "qapi/qmp/qobject.h"
16 #include "qapi/qmp/qerror.h"
17 #include "qapi/visitor.h"
18 #include "qapi/visitor-impl.h"
19
20 void visit_start_handle(Visitor *v, void **obj, const char *kind,
21 const char *name, Error **errp)
22 {
23 if (!error_is_set(errp) && v->start_handle) {
24 v->start_handle(v, obj, kind, name, errp);
25 }
26 }
27
28 void visit_end_handle(Visitor *v, Error **errp)
29 {
30 if (!error_is_set(errp) && v->end_handle) {
31 v->end_handle(v, errp);
32 }
33 }
34
35 void visit_start_struct(Visitor *v, void **obj, const char *kind,
36 const char *name, size_t size, Error **errp)
37 {
38 if (!error_is_set(errp)) {
39 v->start_struct(v, obj, kind, name, size, errp);
40 }
41 }
42
43 void visit_end_struct(Visitor *v, Error **errp)
44 {
45 assert(!error_is_set(errp));
46 v->end_struct(v, errp);
47 }
48
49 void visit_start_implicit_struct(Visitor *v, void **obj, size_t size,
50 Error **errp)
51 {
52 if (!error_is_set(errp) && v->start_implicit_struct) {
53 v->start_implicit_struct(v, obj, size, errp);
54 }
55 }
56
57 void visit_end_implicit_struct(Visitor *v, Error **errp)
58 {
59 assert(!error_is_set(errp));
60 if (v->end_implicit_struct) {
61 v->end_implicit_struct(v, errp);
62 }
63 }
64
65 void visit_start_list(Visitor *v, const char *name, Error **errp)
66 {
67 if (!error_is_set(errp)) {
68 v->start_list(v, name, errp);
69 }
70 }
71
72 GenericList *visit_next_list(Visitor *v, GenericList **list, Error **errp)
73 {
74 if (!error_is_set(errp)) {
75 return v->next_list(v, list, errp);
76 }
77
78 return 0;
79 }
80
81 void visit_end_list(Visitor *v, Error **errp)
82 {
83 assert(!error_is_set(errp));
84 v->end_list(v, errp);
85 }
86
87 void visit_start_optional(Visitor *v, bool *present, const char *name,
88 Error **errp)
89 {
90 if (!error_is_set(errp) && v->start_optional) {
91 v->start_optional(v, present, name, errp);
92 }
93 }
94
95 void visit_end_optional(Visitor *v, Error **errp)
96 {
97 if (!error_is_set(errp) && v->end_optional) {
98 v->end_optional(v, errp);
99 }
100 }
101
102 void visit_get_next_type(Visitor *v, int *obj, const int *qtypes,
103 const char *name, Error **errp)
104 {
105 if (!error_is_set(errp) && v->get_next_type) {
106 v->get_next_type(v, obj, qtypes, name, errp);
107 }
108 }
109
110 void visit_type_enum(Visitor *v, int *obj, const char *strings[],
111 const char *kind, const char *name, Error **errp)
112 {
113 if (!error_is_set(errp)) {
114 v->type_enum(v, obj, strings, kind, name, errp);
115 }
116 }
117
118 void visit_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp)
119 {
120 if (!error_is_set(errp)) {
121 v->type_int(v, obj, name, errp);
122 }
123 }
124
125 void visit_type_uint8(Visitor *v, uint8_t *obj, const char *name, Error **errp)
126 {
127 int64_t value;
128 if (!error_is_set(errp)) {
129 if (v->type_uint8) {
130 v->type_uint8(v, obj, name, errp);
131 } else {
132 value = *obj;
133 v->type_int(v, &value, name, errp);
134 if (value < 0 || value > UINT8_MAX) {
135 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
136 "uint8_t");
137 return;
138 }
139 *obj = value;
140 }
141 }
142 }
143
144 void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp)
145 {
146 int64_t value;
147 if (!error_is_set(errp)) {
148 if (v->type_uint16) {
149 v->type_uint16(v, obj, name, errp);
150 } else {
151 value = *obj;
152 v->type_int(v, &value, name, errp);
153 if (value < 0 || value > UINT16_MAX) {
154 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
155 "uint16_t");
156 return;
157 }
158 *obj = value;
159 }
160 }
161 }
162
163 void visit_type_uint32(Visitor *v, uint32_t *obj, const char *name, Error **errp)
164 {
165 int64_t value;
166 if (!error_is_set(errp)) {
167 if (v->type_uint32) {
168 v->type_uint32(v, obj, name, errp);
169 } else {
170 value = *obj;
171 v->type_int(v, &value, name, errp);
172 if (value < 0 || value > UINT32_MAX) {
173 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
174 "uint32_t");
175 return;
176 }
177 *obj = value;
178 }
179 }
180 }
181
182 void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp)
183 {
184 int64_t value;
185 if (!error_is_set(errp)) {
186 if (v->type_uint64) {
187 v->type_uint64(v, obj, name, errp);
188 } else {
189 value = *obj;
190 v->type_int(v, &value, name, errp);
191 *obj = value;
192 }
193 }
194 }
195
196 void visit_type_int8(Visitor *v, int8_t *obj, const char *name, Error **errp)
197 {
198 int64_t value;
199 if (!error_is_set(errp)) {
200 if (v->type_int8) {
201 v->type_int8(v, obj, name, errp);
202 } else {
203 value = *obj;
204 v->type_int(v, &value, name, errp);
205 if (value < INT8_MIN || value > INT8_MAX) {
206 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
207 "int8_t");
208 return;
209 }
210 *obj = value;
211 }
212 }
213 }
214
215 void visit_type_int16(Visitor *v, int16_t *obj, const char *name, Error **errp)
216 {
217 int64_t value;
218 if (!error_is_set(errp)) {
219 if (v->type_int16) {
220 v->type_int16(v, obj, name, errp);
221 } else {
222 value = *obj;
223 v->type_int(v, &value, name, errp);
224 if (value < INT16_MIN || value > INT16_MAX) {
225 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
226 "int16_t");
227 return;
228 }
229 *obj = value;
230 }
231 }
232 }
233
234 void visit_type_int32(Visitor *v, int32_t *obj, const char *name, Error **errp)
235 {
236 int64_t value;
237 if (!error_is_set(errp)) {
238 if (v->type_int32) {
239 v->type_int32(v, obj, name, errp);
240 } else {
241 value = *obj;
242 v->type_int(v, &value, name, errp);
243 if (value < INT32_MIN || value > INT32_MAX) {
244 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
245 "int32_t");
246 return;
247 }
248 *obj = value;
249 }
250 }
251 }
252
253 void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp)
254 {
255 if (!error_is_set(errp)) {
256 if (v->type_int64) {
257 v->type_int64(v, obj, name, errp);
258 } else {
259 v->type_int(v, obj, name, errp);
260 }
261 }
262 }
263
264 void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
265 {
266 int64_t value;
267 if (!error_is_set(errp)) {
268 if (v->type_size) {
269 v->type_size(v, obj, name, errp);
270 } else if (v->type_uint64) {
271 v->type_uint64(v, obj, name, errp);
272 } else {
273 value = *obj;
274 v->type_int(v, &value, name, errp);
275 *obj = value;
276 }
277 }
278 }
279
280 void visit_type_bool(Visitor *v, bool *obj, const char *name, Error **errp)
281 {
282 if (!error_is_set(errp)) {
283 v->type_bool(v, obj, name, errp);
284 }
285 }
286
287 void visit_type_str(Visitor *v, char **obj, const char *name, Error **errp)
288 {
289 if (!error_is_set(errp)) {
290 v->type_str(v, obj, name, errp);
291 }
292 }
293
294 void visit_type_number(Visitor *v, double *obj, const char *name, Error **errp)
295 {
296 if (!error_is_set(errp)) {
297 v->type_number(v, obj, name, errp);
298 }
299 }
300
301 void output_type_enum(Visitor *v, int *obj, const char *strings[],
302 const char *kind, const char *name,
303 Error **errp)
304 {
305 int i = 0;
306 int value = *obj;
307 char *enum_str;
308
309 assert(strings);
310 while (strings[i++] != NULL);
311 if (value < 0 || value >= i - 1) {
312 error_set(errp, QERR_INVALID_PARAMETER, name ? name : "null");
313 return;
314 }
315
316 enum_str = (char *)strings[value];
317 visit_type_str(v, &enum_str, name, errp);
318 }
319
320 void input_type_enum(Visitor *v, int *obj, const char *strings[],
321 const char *kind, const char *name,
322 Error **errp)
323 {
324 int64_t value = 0;
325 char *enum_str;
326
327 assert(strings);
328
329 visit_type_str(v, &enum_str, name, errp);
330 if (error_is_set(errp)) {
331 return;
332 }
333
334 while (strings[value] != NULL) {
335 if (strcmp(strings[value], enum_str) == 0) {
336 break;
337 }
338 value++;
339 }
340
341 if (strings[value] == NULL) {
342 error_set(errp, QERR_INVALID_PARAMETER, enum_str);
343 g_free(enum_str);
344 return;
345 }
346
347 g_free(enum_str);
348 *obj = value;
349 }