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 static void visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
  99                              uint64_t max, const char *type, Error **errp)
 100 {
 101     Error *err = NULL;
 102     uint64_t value = *obj;
 103
 104     v->type_uint64(v, &value, name, &err);
 105     if (err) {
 106         error_propagate(errp, err);
 107     } else if (value > max) {
 108         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 109                    name ? name : "null", type);
 110     } else {
 111         *obj = value;
 112     }
 113 }
 114
 115 void visit_type_uint8(Visitor *v, uint8_t *obj, const char *name, Error **errp)
 116 {
 117     uint64_t value = *obj;
 118     visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
 119     *obj = value;
 120 }
 121
 122 void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name,
 123                        Error **errp)
 124 {
 125     uint64_t value = *obj;
 126     visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
 127     *obj = value;
 128 }
 129
 130 void visit_type_uint32(Visitor *v, uint32_t *obj, const char *name,
 131                        Error **errp)
 132 {
 133     uint64_t value = *obj;
 134     visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
 135     *obj = value;
 136 }
 137
 138 void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name,
 139                        Error **errp)
 140 {
 141     v->type_uint64(v, obj, name, errp);
 142 }
 143
 144 static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
 145                             int64_t min, int64_t max, const char *type,
 146                             Error **errp)
 147 {
 148     Error *err = NULL;
 149     int64_t value = *obj;
 150
 151     v->type_int64(v, &value, name, &err);
 152     if (err) {
 153         error_propagate(errp, err);
 154     } else if (value < min || value > max) {
 155         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 156                    name ? name : "null", type);
 157     } else {
 158         *obj = value;
 159     }
 160 }
 161
 162 void visit_type_int8(Visitor *v, int8_t *obj, const char *name, Error **errp)
 163 {
 164     int64_t value = *obj;
 165     visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
 166     *obj = value;
 167 }
 168
 169 void visit_type_int16(Visitor *v, int16_t *obj, const char *name, Error **errp)
 170 {
 171     int64_t value = *obj;
 172     visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
 173     *obj = value;
 174 }
 175
 176 void visit_type_int32(Visitor *v, int32_t *obj, const char *name, Error **errp)
 177 {
 178     int64_t value = *obj;
 179     visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
 180     *obj = value;
 181 }
 182
 183 void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp)
 184 {
 185     v->type_int64(v, obj, name, errp);
 186 }
 187
 188 void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
 189 {
 190     if (v->type_size) {
 191         v->type_size(v, obj, name, errp);
 192     } else {
 193         v->type_uint64(v, obj, name, errp);
 194     }
 195 }
 196
 197 void visit_type_bool(Visitor *v, bool *obj, const char *name, Error **errp)
 198 {
 199     v->type_bool(v, obj, name, errp);
 200 }
 201
 202 void visit_type_str(Visitor *v, char **obj, const char *name, Error **errp)
 203 {
 204     v->type_str(v, obj, name, errp);
 205 }
 206
 207 void visit_type_number(Visitor *v, double *obj, const char *name, Error **errp)
 208 {
 209     v->type_number(v, obj, name, errp);
 210 }
 211
 212 void visit_type_any(Visitor *v, QObject **obj, const char *name,
 213                     Error **errp)
 214 {
 215     v->type_any(v, obj, name, errp);
 216 }
 217
 218 void output_type_enum(Visitor *v, int *obj, const char * const strings[],
 219                       const char *kind, const char *name,
 220                       Error **errp)
 221 {
 222     int i = 0;
 223     int value = *obj;
 224     char *enum_str;
 225
 226     assert(strings);
 227     while (strings[i++] != NULL);
 228     if (value < 0 || value >= i - 1) {
 229         error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
 230         return;
 231     }
 232
 233     enum_str = (char *)strings[value];
 234     visit_type_str(v, &enum_str, name, errp);
 235 }
 236
 237 void input_type_enum(Visitor *v, int *obj, const char * const strings[],
 238                      const char *kind, const char *name,
 239                      Error **errp)
 240 {
 241     Error *local_err = NULL;
 242     int64_t value = 0;
 243     char *enum_str;
 244
 245     assert(strings);
 246
 247     visit_type_str(v, &enum_str, name, &local_err);
 248     if (local_err) {
 249         error_propagate(errp, local_err);
 250         return;
 251     }
 252
 253     while (strings[value] != NULL) {
 254         if (strcmp(strings[value], enum_str) == 0) {
 255             break;
 256         }
 257         value++;
 258     }
 259
 260     if (strings[value] == NULL) {
 261         error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
 262         g_free(enum_str);
 263         return;
 264     }
 265
 266     g_free(enum_str);
 267     *obj = value;
 268 }