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