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     uint64_t value;
 101
 102     if (v->type_uint8) {
 103         v->type_uint8(v, obj, name, errp);
 104     } else {
 105         value = *obj;
 106         v->type_uint64(v, &value, name, errp);
 107         if (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     uint64_t value;
 121
 122     if (v->type_uint16) {
 123         v->type_uint16(v, obj, name, errp);
 124     } else {
 125         value = *obj;
 126         v->type_uint64(v, &value, name, errp);
 127         if (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     uint64_t value;
 141
 142     if (v->type_uint32) {
 143         v->type_uint32(v, obj, name, errp);
 144     } else {
 145         value = *obj;
 146         v->type_uint64(v, &value, name, errp);
 147         if (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     v->type_uint64(v, obj, name, errp);
 161 }
 162
 163 void visit_type_int8(Visitor *v, int8_t *obj, const char *name, Error **errp)
 164 {
 165     int64_t value;
 166
 167     if (v->type_int8) {
 168         v->type_int8(v, obj, name, errp);
 169     } else {
 170         value = *obj;
 171         v->type_int64(v, &value, name, errp);
 172         if (value < INT8_MIN || value > INT8_MAX) {
 173             /* FIXME questionable reuse of errp if callback changed
 174                value on error */
 175             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 176                        name ? name : "null", "int8_t");
 177             return;
 178         }
 179         *obj = value;
 180     }
 181 }
 182
 183 void visit_type_int16(Visitor *v, int16_t *obj, const char *name, Error **errp)
 184 {
 185     int64_t value;
 186
 187     if (v->type_int16) {
 188         v->type_int16(v, obj, name, errp);
 189     } else {
 190         value = *obj;
 191         v->type_int64(v, &value, name, errp);
 192         if (value < INT16_MIN || value > INT16_MAX) {
 193             /* FIXME questionable reuse of errp if callback changed
 194                value on error */
 195             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 196                        name ? name : "null", "int16_t");
 197             return;
 198         }
 199         *obj = value;
 200     }
 201 }
 202
 203 void visit_type_int32(Visitor *v, int32_t *obj, const char *name, Error **errp)
 204 {
 205     int64_t value;
 206
 207     if (v->type_int32) {
 208         v->type_int32(v, obj, name, errp);
 209     } else {
 210         value = *obj;
 211         v->type_int64(v, &value, name, errp);
 212         if (value < INT32_MIN || value > INT32_MAX) {
 213             /* FIXME questionable reuse of errp if callback changed
 214                value on error */
 215             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 216                        name ? name : "null", "int32_t");
 217             return;
 218         }
 219         *obj = value;
 220     }
 221 }
 222
 223 void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp)
 224 {
 225     v->type_int64(v, obj, name, errp);
 226 }
 227
 228 void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
 229 {
 230     if (v->type_size) {
 231         v->type_size(v, obj, name, errp);
 232     } else {
 233         v->type_uint64(v, obj, name, errp);
 234     }
 235 }
 236
 237 void visit_type_bool(Visitor *v, bool *obj, const char *name, Error **errp)
 238 {
 239     v->type_bool(v, obj, name, errp);
 240 }
 241
 242 void visit_type_str(Visitor *v, char **obj, const char *name, Error **errp)
 243 {
 244     v->type_str(v, obj, name, errp);
 245 }
 246
 247 void visit_type_number(Visitor *v, double *obj, const char *name, Error **errp)
 248 {
 249     v->type_number(v, obj, name, errp);
 250 }
 251
 252 void visit_type_any(Visitor *v, QObject **obj, const char *name,
 253                     Error **errp)
 254 {
 255     v->type_any(v, obj, name, errp);
 256 }
 257
 258 void output_type_enum(Visitor *v, int *obj, const char * const strings[],
 259                       const char *kind, const char *name,
 260                       Error **errp)
 261 {
 262     int i = 0;
 263     int value = *obj;
 264     char *enum_str;
 265
 266     assert(strings);
 267     while (strings[i++] != NULL);
 268     if (value < 0 || value >= i - 1) {
 269         error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
 270         return;
 271     }
 272
 273     enum_str = (char *)strings[value];
 274     visit_type_str(v, &enum_str, name, errp);
 275 }
 276
 277 void input_type_enum(Visitor *v, int *obj, const char * const strings[],
 278                      const char *kind, const char *name,
 279                      Error **errp)
 280 {
 281     Error *local_err = NULL;
 282     int64_t value = 0;
 283     char *enum_str;
 284
 285     assert(strings);
 286
 287     visit_type_str(v, &enum_str, name, &local_err);
 288     if (local_err) {
 289         error_propagate(errp, local_err);
 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_setg(errp, QERR_INVALID_PARAMETER, enum_str);
 302         g_free(enum_str);
 303         return;
 304     }
 305
 306     g_free(enum_str);
 307     *obj = value;
 308 }