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/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 * const 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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 114                        name ? name : "null", "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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 132                        name ? name : "null", "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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 150                        name ? name : "null", "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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 181                        name ? name : "null", "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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 199                        name ? name : "null", "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_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 217                        name ? name : "null", "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 * const 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_setg(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 * const 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_setg(errp, QERR_INVALID_PARAMETER, enum_str);
 307         g_free(enum_str);
 308         return;
 309     }
 310
 311     g_free(enum_str);
 312     *obj = value;
 313 }