qapi/qapi-visit-core.c

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