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-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 20 void 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 26 void visit_end_struct(Visitor *v, Error **errp) 27 { 28 v->end_struct(v, errp); 29 } 30 31 void 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 39 void 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 46 void visit_start_list(Visitor *v, const char *name, Error **errp) 47 { 48 v->start_list(v, name, errp); 49 } 50 51 GenericList *visit_next_list(Visitor *v, GenericList **list, Error **errp) 52 { 53 return v->next_list(v, list, errp); 54 } 55 56 void visit_end_list(Visitor *v, Error **errp) 57 { 58 v->end_list(v, errp); 59 } 60 61 bool 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 69 void 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 76 void 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 84 void 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 92 void 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 98 void visit_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp) 99 { 100 v->type_int(v, obj, name, errp); 101 } 102 103 void 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 121 void 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 139 void 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 157 void 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 170 void 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 188 void 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 206 void 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 224 void 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 233 void 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 248 void visit_type_bool(Visitor *v, bool *obj, const char *name, Error **errp) 249 { 250 v->type_bool(v, obj, name, errp); 251 } 252 253 void visit_type_str(Visitor *v, char **obj, const char *name, Error **errp) 254 { 255 v->type_str(v, obj, name, errp); 256 } 257 258 void visit_type_number(Visitor *v, double *obj, const char *name, Error **errp) 259 { 260 v->type_number(v, obj, name, errp); 261 } 262 263 void 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 282 void 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