1 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ |
2 | |
3 | /* |
4 | * Built-in QAPI visitors |
5 | * |
6 | * Copyright IBM, Corp. 2011 |
7 | * Copyright (C) 2014-2018 Red Hat, Inc. |
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 | #include "qemu/osdep.h" |
14 | #include "qapi/error.h" |
15 | #include "qapi/qapi-builtin-visit.h" |
16 | |
17 | void visit_type_strList(Visitor *v, const char *name, strList **obj, Error **errp) |
18 | { |
19 | Error *err = NULL; |
20 | strList *tail; |
21 | size_t size = sizeof(**obj); |
22 | |
23 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
24 | if (err) { |
25 | goto out; |
26 | } |
27 | |
28 | for (tail = *obj; tail; |
29 | tail = (strList *)visit_next_list(v, (GenericList *)tail, size)) { |
30 | visit_type_str(v, NULL, &tail->value, &err); |
31 | if (err) { |
32 | break; |
33 | } |
34 | } |
35 | |
36 | if (!err) { |
37 | visit_check_list(v, &err); |
38 | } |
39 | visit_end_list(v, (void **)obj); |
40 | if (err && visit_is_input(v)) { |
41 | qapi_free_strList(*obj); |
42 | *obj = NULL; |
43 | } |
44 | out: |
45 | error_propagate(errp, err); |
46 | } |
47 | |
48 | void visit_type_numberList(Visitor *v, const char *name, numberList **obj, Error **errp) |
49 | { |
50 | Error *err = NULL; |
51 | numberList *tail; |
52 | size_t size = sizeof(**obj); |
53 | |
54 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
55 | if (err) { |
56 | goto out; |
57 | } |
58 | |
59 | for (tail = *obj; tail; |
60 | tail = (numberList *)visit_next_list(v, (GenericList *)tail, size)) { |
61 | visit_type_number(v, NULL, &tail->value, &err); |
62 | if (err) { |
63 | break; |
64 | } |
65 | } |
66 | |
67 | if (!err) { |
68 | visit_check_list(v, &err); |
69 | } |
70 | visit_end_list(v, (void **)obj); |
71 | if (err && visit_is_input(v)) { |
72 | qapi_free_numberList(*obj); |
73 | *obj = NULL; |
74 | } |
75 | out: |
76 | error_propagate(errp, err); |
77 | } |
78 | |
79 | void visit_type_intList(Visitor *v, const char *name, intList **obj, Error **errp) |
80 | { |
81 | Error *err = NULL; |
82 | intList *tail; |
83 | size_t size = sizeof(**obj); |
84 | |
85 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
86 | if (err) { |
87 | goto out; |
88 | } |
89 | |
90 | for (tail = *obj; tail; |
91 | tail = (intList *)visit_next_list(v, (GenericList *)tail, size)) { |
92 | visit_type_int(v, NULL, &tail->value, &err); |
93 | if (err) { |
94 | break; |
95 | } |
96 | } |
97 | |
98 | if (!err) { |
99 | visit_check_list(v, &err); |
100 | } |
101 | visit_end_list(v, (void **)obj); |
102 | if (err && visit_is_input(v)) { |
103 | qapi_free_intList(*obj); |
104 | *obj = NULL; |
105 | } |
106 | out: |
107 | error_propagate(errp, err); |
108 | } |
109 | |
110 | void visit_type_int8List(Visitor *v, const char *name, int8List **obj, Error **errp) |
111 | { |
112 | Error *err = NULL; |
113 | int8List *tail; |
114 | size_t size = sizeof(**obj); |
115 | |
116 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
117 | if (err) { |
118 | goto out; |
119 | } |
120 | |
121 | for (tail = *obj; tail; |
122 | tail = (int8List *)visit_next_list(v, (GenericList *)tail, size)) { |
123 | visit_type_int8(v, NULL, &tail->value, &err); |
124 | if (err) { |
125 | break; |
126 | } |
127 | } |
128 | |
129 | if (!err) { |
130 | visit_check_list(v, &err); |
131 | } |
132 | visit_end_list(v, (void **)obj); |
133 | if (err && visit_is_input(v)) { |
134 | qapi_free_int8List(*obj); |
135 | *obj = NULL; |
136 | } |
137 | out: |
138 | error_propagate(errp, err); |
139 | } |
140 | |
141 | void visit_type_int16List(Visitor *v, const char *name, int16List **obj, Error **errp) |
142 | { |
143 | Error *err = NULL; |
144 | int16List *tail; |
145 | size_t size = sizeof(**obj); |
146 | |
147 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
148 | if (err) { |
149 | goto out; |
150 | } |
151 | |
152 | for (tail = *obj; tail; |
153 | tail = (int16List *)visit_next_list(v, (GenericList *)tail, size)) { |
154 | visit_type_int16(v, NULL, &tail->value, &err); |
155 | if (err) { |
156 | break; |
157 | } |
158 | } |
159 | |
160 | if (!err) { |
161 | visit_check_list(v, &err); |
162 | } |
163 | visit_end_list(v, (void **)obj); |
164 | if (err && visit_is_input(v)) { |
165 | qapi_free_int16List(*obj); |
166 | *obj = NULL; |
167 | } |
168 | out: |
169 | error_propagate(errp, err); |
170 | } |
171 | |
172 | void visit_type_int32List(Visitor *v, const char *name, int32List **obj, Error **errp) |
173 | { |
174 | Error *err = NULL; |
175 | int32List *tail; |
176 | size_t size = sizeof(**obj); |
177 | |
178 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
179 | if (err) { |
180 | goto out; |
181 | } |
182 | |
183 | for (tail = *obj; tail; |
184 | tail = (int32List *)visit_next_list(v, (GenericList *)tail, size)) { |
185 | visit_type_int32(v, NULL, &tail->value, &err); |
186 | if (err) { |
187 | break; |
188 | } |
189 | } |
190 | |
191 | if (!err) { |
192 | visit_check_list(v, &err); |
193 | } |
194 | visit_end_list(v, (void **)obj); |
195 | if (err && visit_is_input(v)) { |
196 | qapi_free_int32List(*obj); |
197 | *obj = NULL; |
198 | } |
199 | out: |
200 | error_propagate(errp, err); |
201 | } |
202 | |
203 | void visit_type_int64List(Visitor *v, const char *name, int64List **obj, Error **errp) |
204 | { |
205 | Error *err = NULL; |
206 | int64List *tail; |
207 | size_t size = sizeof(**obj); |
208 | |
209 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
210 | if (err) { |
211 | goto out; |
212 | } |
213 | |
214 | for (tail = *obj; tail; |
215 | tail = (int64List *)visit_next_list(v, (GenericList *)tail, size)) { |
216 | visit_type_int64(v, NULL, &tail->value, &err); |
217 | if (err) { |
218 | break; |
219 | } |
220 | } |
221 | |
222 | if (!err) { |
223 | visit_check_list(v, &err); |
224 | } |
225 | visit_end_list(v, (void **)obj); |
226 | if (err && visit_is_input(v)) { |
227 | qapi_free_int64List(*obj); |
228 | *obj = NULL; |
229 | } |
230 | out: |
231 | error_propagate(errp, err); |
232 | } |
233 | |
234 | void visit_type_uint8List(Visitor *v, const char *name, uint8List **obj, Error **errp) |
235 | { |
236 | Error *err = NULL; |
237 | uint8List *tail; |
238 | size_t size = sizeof(**obj); |
239 | |
240 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
241 | if (err) { |
242 | goto out; |
243 | } |
244 | |
245 | for (tail = *obj; tail; |
246 | tail = (uint8List *)visit_next_list(v, (GenericList *)tail, size)) { |
247 | visit_type_uint8(v, NULL, &tail->value, &err); |
248 | if (err) { |
249 | break; |
250 | } |
251 | } |
252 | |
253 | if (!err) { |
254 | visit_check_list(v, &err); |
255 | } |
256 | visit_end_list(v, (void **)obj); |
257 | if (err && visit_is_input(v)) { |
258 | qapi_free_uint8List(*obj); |
259 | *obj = NULL; |
260 | } |
261 | out: |
262 | error_propagate(errp, err); |
263 | } |
264 | |
265 | void visit_type_uint16List(Visitor *v, const char *name, uint16List **obj, Error **errp) |
266 | { |
267 | Error *err = NULL; |
268 | uint16List *tail; |
269 | size_t size = sizeof(**obj); |
270 | |
271 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
272 | if (err) { |
273 | goto out; |
274 | } |
275 | |
276 | for (tail = *obj; tail; |
277 | tail = (uint16List *)visit_next_list(v, (GenericList *)tail, size)) { |
278 | visit_type_uint16(v, NULL, &tail->value, &err); |
279 | if (err) { |
280 | break; |
281 | } |
282 | } |
283 | |
284 | if (!err) { |
285 | visit_check_list(v, &err); |
286 | } |
287 | visit_end_list(v, (void **)obj); |
288 | if (err && visit_is_input(v)) { |
289 | qapi_free_uint16List(*obj); |
290 | *obj = NULL; |
291 | } |
292 | out: |
293 | error_propagate(errp, err); |
294 | } |
295 | |
296 | void visit_type_uint32List(Visitor *v, const char *name, uint32List **obj, Error **errp) |
297 | { |
298 | Error *err = NULL; |
299 | uint32List *tail; |
300 | size_t size = sizeof(**obj); |
301 | |
302 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
303 | if (err) { |
304 | goto out; |
305 | } |
306 | |
307 | for (tail = *obj; tail; |
308 | tail = (uint32List *)visit_next_list(v, (GenericList *)tail, size)) { |
309 | visit_type_uint32(v, NULL, &tail->value, &err); |
310 | if (err) { |
311 | break; |
312 | } |
313 | } |
314 | |
315 | if (!err) { |
316 | visit_check_list(v, &err); |
317 | } |
318 | visit_end_list(v, (void **)obj); |
319 | if (err && visit_is_input(v)) { |
320 | qapi_free_uint32List(*obj); |
321 | *obj = NULL; |
322 | } |
323 | out: |
324 | error_propagate(errp, err); |
325 | } |
326 | |
327 | void visit_type_uint64List(Visitor *v, const char *name, uint64List **obj, Error **errp) |
328 | { |
329 | Error *err = NULL; |
330 | uint64List *tail; |
331 | size_t size = sizeof(**obj); |
332 | |
333 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
334 | if (err) { |
335 | goto out; |
336 | } |
337 | |
338 | for (tail = *obj; tail; |
339 | tail = (uint64List *)visit_next_list(v, (GenericList *)tail, size)) { |
340 | visit_type_uint64(v, NULL, &tail->value, &err); |
341 | if (err) { |
342 | break; |
343 | } |
344 | } |
345 | |
346 | if (!err) { |
347 | visit_check_list(v, &err); |
348 | } |
349 | visit_end_list(v, (void **)obj); |
350 | if (err && visit_is_input(v)) { |
351 | qapi_free_uint64List(*obj); |
352 | *obj = NULL; |
353 | } |
354 | out: |
355 | error_propagate(errp, err); |
356 | } |
357 | |
358 | void visit_type_sizeList(Visitor *v, const char *name, sizeList **obj, Error **errp) |
359 | { |
360 | Error *err = NULL; |
361 | sizeList *tail; |
362 | size_t size = sizeof(**obj); |
363 | |
364 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
365 | if (err) { |
366 | goto out; |
367 | } |
368 | |
369 | for (tail = *obj; tail; |
370 | tail = (sizeList *)visit_next_list(v, (GenericList *)tail, size)) { |
371 | visit_type_size(v, NULL, &tail->value, &err); |
372 | if (err) { |
373 | break; |
374 | } |
375 | } |
376 | |
377 | if (!err) { |
378 | visit_check_list(v, &err); |
379 | } |
380 | visit_end_list(v, (void **)obj); |
381 | if (err && visit_is_input(v)) { |
382 | qapi_free_sizeList(*obj); |
383 | *obj = NULL; |
384 | } |
385 | out: |
386 | error_propagate(errp, err); |
387 | } |
388 | |
389 | void visit_type_boolList(Visitor *v, const char *name, boolList **obj, Error **errp) |
390 | { |
391 | Error *err = NULL; |
392 | boolList *tail; |
393 | size_t size = sizeof(**obj); |
394 | |
395 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
396 | if (err) { |
397 | goto out; |
398 | } |
399 | |
400 | for (tail = *obj; tail; |
401 | tail = (boolList *)visit_next_list(v, (GenericList *)tail, size)) { |
402 | visit_type_bool(v, NULL, &tail->value, &err); |
403 | if (err) { |
404 | break; |
405 | } |
406 | } |
407 | |
408 | if (!err) { |
409 | visit_check_list(v, &err); |
410 | } |
411 | visit_end_list(v, (void **)obj); |
412 | if (err && visit_is_input(v)) { |
413 | qapi_free_boolList(*obj); |
414 | *obj = NULL; |
415 | } |
416 | out: |
417 | error_propagate(errp, err); |
418 | } |
419 | |
420 | void visit_type_anyList(Visitor *v, const char *name, anyList **obj, Error **errp) |
421 | { |
422 | Error *err = NULL; |
423 | anyList *tail; |
424 | size_t size = sizeof(**obj); |
425 | |
426 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
427 | if (err) { |
428 | goto out; |
429 | } |
430 | |
431 | for (tail = *obj; tail; |
432 | tail = (anyList *)visit_next_list(v, (GenericList *)tail, size)) { |
433 | visit_type_any(v, NULL, &tail->value, &err); |
434 | if (err) { |
435 | break; |
436 | } |
437 | } |
438 | |
439 | if (!err) { |
440 | visit_check_list(v, &err); |
441 | } |
442 | visit_end_list(v, (void **)obj); |
443 | if (err && visit_is_input(v)) { |
444 | qapi_free_anyList(*obj); |
445 | *obj = NULL; |
446 | } |
447 | out: |
448 | error_propagate(errp, err); |
449 | } |
450 | |
451 | void visit_type_nullList(Visitor *v, const char *name, nullList **obj, Error **errp) |
452 | { |
453 | Error *err = NULL; |
454 | nullList *tail; |
455 | size_t size = sizeof(**obj); |
456 | |
457 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
458 | if (err) { |
459 | goto out; |
460 | } |
461 | |
462 | for (tail = *obj; tail; |
463 | tail = (nullList *)visit_next_list(v, (GenericList *)tail, size)) { |
464 | visit_type_null(v, NULL, &tail->value, &err); |
465 | if (err) { |
466 | break; |
467 | } |
468 | } |
469 | |
470 | if (!err) { |
471 | visit_check_list(v, &err); |
472 | } |
473 | visit_end_list(v, (void **)obj); |
474 | if (err && visit_is_input(v)) { |
475 | qapi_free_nullList(*obj); |
476 | *obj = NULL; |
477 | } |
478 | out: |
479 | error_propagate(errp, err); |
480 | } |
481 | |
482 | void visit_type_QType(Visitor *v, const char *name, QType *obj, Error **errp) |
483 | { |
484 | int value = *obj; |
485 | visit_type_enum(v, name, &value, &QType_lookup, errp); |
486 | *obj = value; |
487 | } |
488 | |
489 | /* Dummy declaration to prevent empty .o file */ |
490 | char qapi_dummy_qapi_builtin_visit_c; |
491 | |