qapi/qapi-visit-core.c

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