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