1/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
2
3/*
4 * Schema-defined 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/qmp/qerror.h"
16#include "qapi-visit-introspect.h"
17
18void visit_type_SchemaInfoList(Visitor *v, const char *name, SchemaInfoList **obj, Error **errp)
19{
20 Error *err = NULL;
21 SchemaInfoList *tail;
22 size_t size = sizeof(**obj);
23
24 visit_start_list(v, name, (GenericList **)obj, size, &err);
25 if (err) {
26 goto out;
27 }
28
29 for (tail = *obj; tail;
30 tail = (SchemaInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
31 visit_type_SchemaInfo(v, NULL, &tail->value, &err);
32 if (err) {
33 break;
34 }
35 }
36
37 if (!err) {
38 visit_check_list(v, &err);
39 }
40 visit_end_list(v, (void **)obj);
41 if (err && visit_is_input(v)) {
42 qapi_free_SchemaInfoList(*obj);
43 *obj = NULL;
44 }
45out:
46 error_propagate(errp, err);
47}
48
49void visit_type_SchemaMetaType(Visitor *v, const char *name, SchemaMetaType *obj, Error **errp)
50{
51 int value = *obj;
52 visit_type_enum(v, name, &value, &SchemaMetaType_lookup, errp);
53 *obj = value;
54}
55
56void visit_type_q_obj_SchemaInfo_base_members(Visitor *v, q_obj_SchemaInfo_base *obj, Error **errp)
57{
58 Error *err = NULL;
59
60 visit_type_str(v, "name", &obj->name, &err);
61 if (err) {
62 goto out;
63 }
64 visit_type_SchemaMetaType(v, "meta-type", &obj->meta_type, &err);
65 if (err) {
66 goto out;
67 }
68
69out:
70 error_propagate(errp, err);
71}
72
73void visit_type_SchemaInfo_members(Visitor *v, SchemaInfo *obj, Error **errp)
74{
75 Error *err = NULL;
76
77 visit_type_q_obj_SchemaInfo_base_members(v, (q_obj_SchemaInfo_base *)obj, &err);
78 if (err) {
79 goto out;
80 }
81 switch (obj->meta_type) {
82 case SCHEMA_META_TYPE_BUILTIN:
83 visit_type_SchemaInfoBuiltin_members(v, &obj->u.builtin, &err);
84 break;
85 case SCHEMA_META_TYPE_ENUM:
86 visit_type_SchemaInfoEnum_members(v, &obj->u.q_enum, &err);
87 break;
88 case SCHEMA_META_TYPE_ARRAY:
89 visit_type_SchemaInfoArray_members(v, &obj->u.array, &err);
90 break;
91 case SCHEMA_META_TYPE_OBJECT:
92 visit_type_SchemaInfoObject_members(v, &obj->u.object, &err);
93 break;
94 case SCHEMA_META_TYPE_ALTERNATE:
95 visit_type_SchemaInfoAlternate_members(v, &obj->u.alternate, &err);
96 break;
97 case SCHEMA_META_TYPE_COMMAND:
98 visit_type_SchemaInfoCommand_members(v, &obj->u.command, &err);
99 break;
100 case SCHEMA_META_TYPE_EVENT:
101 visit_type_SchemaInfoEvent_members(v, &obj->u.event, &err);
102 break;
103 default:
104 abort();
105 }
106
107out:
108 error_propagate(errp, err);
109}
110
111void visit_type_SchemaInfo(Visitor *v, const char *name, SchemaInfo **obj, Error **errp)
112{
113 Error *err = NULL;
114
115 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfo), &err);
116 if (err) {
117 goto out;
118 }
119 if (!*obj) {
120 goto out_obj;
121 }
122 visit_type_SchemaInfo_members(v, *obj, &err);
123 if (err) {
124 goto out_obj;
125 }
126 visit_check_struct(v, &err);
127out_obj:
128 visit_end_struct(v, (void **)obj);
129 if (err && visit_is_input(v)) {
130 qapi_free_SchemaInfo(*obj);
131 *obj = NULL;
132 }
133out:
134 error_propagate(errp, err);
135}
136
137void visit_type_SchemaInfoBuiltin_members(Visitor *v, SchemaInfoBuiltin *obj, Error **errp)
138{
139 Error *err = NULL;
140
141 visit_type_JSONType(v, "json-type", &obj->json_type, &err);
142 if (err) {
143 goto out;
144 }
145
146out:
147 error_propagate(errp, err);
148}
149
150void visit_type_SchemaInfoBuiltin(Visitor *v, const char *name, SchemaInfoBuiltin **obj, Error **errp)
151{
152 Error *err = NULL;
153
154 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoBuiltin), &err);
155 if (err) {
156 goto out;
157 }
158 if (!*obj) {
159 goto out_obj;
160 }
161 visit_type_SchemaInfoBuiltin_members(v, *obj, &err);
162 if (err) {
163 goto out_obj;
164 }
165 visit_check_struct(v, &err);
166out_obj:
167 visit_end_struct(v, (void **)obj);
168 if (err && visit_is_input(v)) {
169 qapi_free_SchemaInfoBuiltin(*obj);
170 *obj = NULL;
171 }
172out:
173 error_propagate(errp, err);
174}
175
176void visit_type_JSONType(Visitor *v, const char *name, JSONType *obj, Error **errp)
177{
178 int value = *obj;
179 visit_type_enum(v, name, &value, &JSONType_lookup, errp);
180 *obj = value;
181}
182
183void visit_type_SchemaInfoEnum_members(Visitor *v, SchemaInfoEnum *obj, Error **errp)
184{
185 Error *err = NULL;
186
187 visit_type_strList(v, "values", &obj->values, &err);
188 if (err) {
189 goto out;
190 }
191
192out:
193 error_propagate(errp, err);
194}
195
196void visit_type_SchemaInfoEnum(Visitor *v, const char *name, SchemaInfoEnum **obj, Error **errp)
197{
198 Error *err = NULL;
199
200 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoEnum), &err);
201 if (err) {
202 goto out;
203 }
204 if (!*obj) {
205 goto out_obj;
206 }
207 visit_type_SchemaInfoEnum_members(v, *obj, &err);
208 if (err) {
209 goto out_obj;
210 }
211 visit_check_struct(v, &err);
212out_obj:
213 visit_end_struct(v, (void **)obj);
214 if (err && visit_is_input(v)) {
215 qapi_free_SchemaInfoEnum(*obj);
216 *obj = NULL;
217 }
218out:
219 error_propagate(errp, err);
220}
221
222void visit_type_SchemaInfoArray_members(Visitor *v, SchemaInfoArray *obj, Error **errp)
223{
224 Error *err = NULL;
225
226 visit_type_str(v, "element-type", &obj->element_type, &err);
227 if (err) {
228 goto out;
229 }
230
231out:
232 error_propagate(errp, err);
233}
234
235void visit_type_SchemaInfoArray(Visitor *v, const char *name, SchemaInfoArray **obj, Error **errp)
236{
237 Error *err = NULL;
238
239 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoArray), &err);
240 if (err) {
241 goto out;
242 }
243 if (!*obj) {
244 goto out_obj;
245 }
246 visit_type_SchemaInfoArray_members(v, *obj, &err);
247 if (err) {
248 goto out_obj;
249 }
250 visit_check_struct(v, &err);
251out_obj:
252 visit_end_struct(v, (void **)obj);
253 if (err && visit_is_input(v)) {
254 qapi_free_SchemaInfoArray(*obj);
255 *obj = NULL;
256 }
257out:
258 error_propagate(errp, err);
259}
260
261void visit_type_SchemaInfoObjectMemberList(Visitor *v, const char *name, SchemaInfoObjectMemberList **obj, Error **errp)
262{
263 Error *err = NULL;
264 SchemaInfoObjectMemberList *tail;
265 size_t size = sizeof(**obj);
266
267 visit_start_list(v, name, (GenericList **)obj, size, &err);
268 if (err) {
269 goto out;
270 }
271
272 for (tail = *obj; tail;
273 tail = (SchemaInfoObjectMemberList *)visit_next_list(v, (GenericList *)tail, size)) {
274 visit_type_SchemaInfoObjectMember(v, NULL, &tail->value, &err);
275 if (err) {
276 break;
277 }
278 }
279
280 if (!err) {
281 visit_check_list(v, &err);
282 }
283 visit_end_list(v, (void **)obj);
284 if (err && visit_is_input(v)) {
285 qapi_free_SchemaInfoObjectMemberList(*obj);
286 *obj = NULL;
287 }
288out:
289 error_propagate(errp, err);
290}
291
292void visit_type_SchemaInfoObjectVariantList(Visitor *v, const char *name, SchemaInfoObjectVariantList **obj, Error **errp)
293{
294 Error *err = NULL;
295 SchemaInfoObjectVariantList *tail;
296 size_t size = sizeof(**obj);
297
298 visit_start_list(v, name, (GenericList **)obj, size, &err);
299 if (err) {
300 goto out;
301 }
302
303 for (tail = *obj; tail;
304 tail = (SchemaInfoObjectVariantList *)visit_next_list(v, (GenericList *)tail, size)) {
305 visit_type_SchemaInfoObjectVariant(v, NULL, &tail->value, &err);
306 if (err) {
307 break;
308 }
309 }
310
311 if (!err) {
312 visit_check_list(v, &err);
313 }
314 visit_end_list(v, (void **)obj);
315 if (err && visit_is_input(v)) {
316 qapi_free_SchemaInfoObjectVariantList(*obj);
317 *obj = NULL;
318 }
319out:
320 error_propagate(errp, err);
321}
322
323void visit_type_SchemaInfoObject_members(Visitor *v, SchemaInfoObject *obj, Error **errp)
324{
325 Error *err = NULL;
326
327 visit_type_SchemaInfoObjectMemberList(v, "members", &obj->members, &err);
328 if (err) {
329 goto out;
330 }
331 if (visit_optional(v, "tag", &obj->has_tag)) {
332 visit_type_str(v, "tag", &obj->tag, &err);
333 if (err) {
334 goto out;
335 }
336 }
337 if (visit_optional(v, "variants", &obj->has_variants)) {
338 visit_type_SchemaInfoObjectVariantList(v, "variants", &obj->variants, &err);
339 if (err) {
340 goto out;
341 }
342 }
343 if (visit_optional(v, "features", &obj->has_features)) {
344 visit_type_strList(v, "features", &obj->features, &err);
345 if (err) {
346 goto out;
347 }
348 }
349
350out:
351 error_propagate(errp, err);
352}
353
354void visit_type_SchemaInfoObject(Visitor *v, const char *name, SchemaInfoObject **obj, Error **errp)
355{
356 Error *err = NULL;
357
358 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObject), &err);
359 if (err) {
360 goto out;
361 }
362 if (!*obj) {
363 goto out_obj;
364 }
365 visit_type_SchemaInfoObject_members(v, *obj, &err);
366 if (err) {
367 goto out_obj;
368 }
369 visit_check_struct(v, &err);
370out_obj:
371 visit_end_struct(v, (void **)obj);
372 if (err && visit_is_input(v)) {
373 qapi_free_SchemaInfoObject(*obj);
374 *obj = NULL;
375 }
376out:
377 error_propagate(errp, err);
378}
379
380void visit_type_SchemaInfoObjectMember_members(Visitor *v, SchemaInfoObjectMember *obj, Error **errp)
381{
382 Error *err = NULL;
383
384 visit_type_str(v, "name", &obj->name, &err);
385 if (err) {
386 goto out;
387 }
388 visit_type_str(v, "type", &obj->type, &err);
389 if (err) {
390 goto out;
391 }
392 if (visit_optional(v, "default", &obj->has_q_default)) {
393 visit_type_any(v, "default", &obj->q_default, &err);
394 if (err) {
395 goto out;
396 }
397 }
398
399out:
400 error_propagate(errp, err);
401}
402
403void visit_type_SchemaInfoObjectMember(Visitor *v, const char *name, SchemaInfoObjectMember **obj, Error **errp)
404{
405 Error *err = NULL;
406
407 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObjectMember), &err);
408 if (err) {
409 goto out;
410 }
411 if (!*obj) {
412 goto out_obj;
413 }
414 visit_type_SchemaInfoObjectMember_members(v, *obj, &err);
415 if (err) {
416 goto out_obj;
417 }
418 visit_check_struct(v, &err);
419out_obj:
420 visit_end_struct(v, (void **)obj);
421 if (err && visit_is_input(v)) {
422 qapi_free_SchemaInfoObjectMember(*obj);
423 *obj = NULL;
424 }
425out:
426 error_propagate(errp, err);
427}
428
429void visit_type_SchemaInfoObjectVariant_members(Visitor *v, SchemaInfoObjectVariant *obj, Error **errp)
430{
431 Error *err = NULL;
432
433 visit_type_str(v, "case", &obj->q_case, &err);
434 if (err) {
435 goto out;
436 }
437 visit_type_str(v, "type", &obj->type, &err);
438 if (err) {
439 goto out;
440 }
441
442out:
443 error_propagate(errp, err);
444}
445
446void visit_type_SchemaInfoObjectVariant(Visitor *v, const char *name, SchemaInfoObjectVariant **obj, Error **errp)
447{
448 Error *err = NULL;
449
450 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObjectVariant), &err);
451 if (err) {
452 goto out;
453 }
454 if (!*obj) {
455 goto out_obj;
456 }
457 visit_type_SchemaInfoObjectVariant_members(v, *obj, &err);
458 if (err) {
459 goto out_obj;
460 }
461 visit_check_struct(v, &err);
462out_obj:
463 visit_end_struct(v, (void **)obj);
464 if (err && visit_is_input(v)) {
465 qapi_free_SchemaInfoObjectVariant(*obj);
466 *obj = NULL;
467 }
468out:
469 error_propagate(errp, err);
470}
471
472void visit_type_SchemaInfoAlternateMemberList(Visitor *v, const char *name, SchemaInfoAlternateMemberList **obj, Error **errp)
473{
474 Error *err = NULL;
475 SchemaInfoAlternateMemberList *tail;
476 size_t size = sizeof(**obj);
477
478 visit_start_list(v, name, (GenericList **)obj, size, &err);
479 if (err) {
480 goto out;
481 }
482
483 for (tail = *obj; tail;
484 tail = (SchemaInfoAlternateMemberList *)visit_next_list(v, (GenericList *)tail, size)) {
485 visit_type_SchemaInfoAlternateMember(v, NULL, &tail->value, &err);
486 if (err) {
487 break;
488 }
489 }
490
491 if (!err) {
492 visit_check_list(v, &err);
493 }
494 visit_end_list(v, (void **)obj);
495 if (err && visit_is_input(v)) {
496 qapi_free_SchemaInfoAlternateMemberList(*obj);
497 *obj = NULL;
498 }
499out:
500 error_propagate(errp, err);
501}
502
503void visit_type_SchemaInfoAlternate_members(Visitor *v, SchemaInfoAlternate *obj, Error **errp)
504{
505 Error *err = NULL;
506
507 visit_type_SchemaInfoAlternateMemberList(v, "members", &obj->members, &err);
508 if (err) {
509 goto out;
510 }
511
512out:
513 error_propagate(errp, err);
514}
515
516void visit_type_SchemaInfoAlternate(Visitor *v, const char *name, SchemaInfoAlternate **obj, Error **errp)
517{
518 Error *err = NULL;
519
520 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoAlternate), &err);
521 if (err) {
522 goto out;
523 }
524 if (!*obj) {
525 goto out_obj;
526 }
527 visit_type_SchemaInfoAlternate_members(v, *obj, &err);
528 if (err) {
529 goto out_obj;
530 }
531 visit_check_struct(v, &err);
532out_obj:
533 visit_end_struct(v, (void **)obj);
534 if (err && visit_is_input(v)) {
535 qapi_free_SchemaInfoAlternate(*obj);
536 *obj = NULL;
537 }
538out:
539 error_propagate(errp, err);
540}
541
542void visit_type_SchemaInfoAlternateMember_members(Visitor *v, SchemaInfoAlternateMember *obj, Error **errp)
543{
544 Error *err = NULL;
545
546 visit_type_str(v, "type", &obj->type, &err);
547 if (err) {
548 goto out;
549 }
550
551out:
552 error_propagate(errp, err);
553}
554
555void visit_type_SchemaInfoAlternateMember(Visitor *v, const char *name, SchemaInfoAlternateMember **obj, Error **errp)
556{
557 Error *err = NULL;
558
559 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoAlternateMember), &err);
560 if (err) {
561 goto out;
562 }
563 if (!*obj) {
564 goto out_obj;
565 }
566 visit_type_SchemaInfoAlternateMember_members(v, *obj, &err);
567 if (err) {
568 goto out_obj;
569 }
570 visit_check_struct(v, &err);
571out_obj:
572 visit_end_struct(v, (void **)obj);
573 if (err && visit_is_input(v)) {
574 qapi_free_SchemaInfoAlternateMember(*obj);
575 *obj = NULL;
576 }
577out:
578 error_propagate(errp, err);
579}
580
581void visit_type_SchemaInfoCommand_members(Visitor *v, SchemaInfoCommand *obj, Error **errp)
582{
583 Error *err = NULL;
584
585 visit_type_str(v, "arg-type", &obj->arg_type, &err);
586 if (err) {
587 goto out;
588 }
589 visit_type_str(v, "ret-type", &obj->ret_type, &err);
590 if (err) {
591 goto out;
592 }
593 if (visit_optional(v, "allow-oob", &obj->has_allow_oob)) {
594 visit_type_bool(v, "allow-oob", &obj->allow_oob, &err);
595 if (err) {
596 goto out;
597 }
598 }
599
600out:
601 error_propagate(errp, err);
602}
603
604void visit_type_SchemaInfoCommand(Visitor *v, const char *name, SchemaInfoCommand **obj, Error **errp)
605{
606 Error *err = NULL;
607
608 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoCommand), &err);
609 if (err) {
610 goto out;
611 }
612 if (!*obj) {
613 goto out_obj;
614 }
615 visit_type_SchemaInfoCommand_members(v, *obj, &err);
616 if (err) {
617 goto out_obj;
618 }
619 visit_check_struct(v, &err);
620out_obj:
621 visit_end_struct(v, (void **)obj);
622 if (err && visit_is_input(v)) {
623 qapi_free_SchemaInfoCommand(*obj);
624 *obj = NULL;
625 }
626out:
627 error_propagate(errp, err);
628}
629
630void visit_type_SchemaInfoEvent_members(Visitor *v, SchemaInfoEvent *obj, Error **errp)
631{
632 Error *err = NULL;
633
634 visit_type_str(v, "arg-type", &obj->arg_type, &err);
635 if (err) {
636 goto out;
637 }
638
639out:
640 error_propagate(errp, err);
641}
642
643void visit_type_SchemaInfoEvent(Visitor *v, const char *name, SchemaInfoEvent **obj, Error **errp)
644{
645 Error *err = NULL;
646
647 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoEvent), &err);
648 if (err) {
649 goto out;
650 }
651 if (!*obj) {
652 goto out_obj;
653 }
654 visit_type_SchemaInfoEvent_members(v, *obj, &err);
655 if (err) {
656 goto out_obj;
657 }
658 visit_check_struct(v, &err);
659out_obj:
660 visit_end_struct(v, (void **)obj);
661 if (err && visit_is_input(v)) {
662 qapi_free_SchemaInfoEvent(*obj);
663 *obj = NULL;
664 }
665out:
666 error_propagate(errp, err);
667}
668
669/* Dummy declaration to prevent empty .o file */
670char qapi_dummy_qapi_visit_introspect_c;
671