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
17void 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 }
44out:
45 error_propagate(errp, err);
46}
47
48void 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 }
75out:
76 error_propagate(errp, err);
77}
78
79void 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 }
106out:
107 error_propagate(errp, err);
108}
109
110void 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 }
137out:
138 error_propagate(errp, err);
139}
140
141void 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 }
168out:
169 error_propagate(errp, err);
170}
171
172void 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 }
199out:
200 error_propagate(errp, err);
201}
202
203void 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 }
230out:
231 error_propagate(errp, err);
232}
233
234void 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 }
261out:
262 error_propagate(errp, err);
263}
264
265void 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 }
292out:
293 error_propagate(errp, err);
294}
295
296void 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 }
323out:
324 error_propagate(errp, err);
325}
326
327void 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 }
354out:
355 error_propagate(errp, err);
356}
357
358void 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 }
385out:
386 error_propagate(errp, err);
387}
388
389void 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 }
416out:
417 error_propagate(errp, err);
418}
419
420void 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 }
447out:
448 error_propagate(errp, err);
449}
450
451void 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 }
478out:
479 error_propagate(errp, err);
480}
481
482void 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 */
490char qapi_dummy_qapi_builtin_visit_c;
491