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