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