Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Core Definitions for QAPI Visitor Classes |
| 3 | * |
Eric Blake | 7c91aab | 2016-01-29 06:48:48 -0700 | [diff] [blame] | 4 | * Copyright (C) 2012-2016 Red Hat, Inc. |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 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 | |
Peter Maydell | cbf2115 | 2016-01-29 17:49:57 +0000 | [diff] [blame] | 15 | #include "qemu/osdep.h" |
Markus Armbruster | 7ce5fc6 | 2021-10-28 12:25:19 +0200 | [diff] [blame] | 16 | #include "qapi/compat-policy.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 17 | #include "qapi/error.h" |
Paolo Bonzini | 7b1b5d1 | 2012-12-17 18:19:43 +0100 | [diff] [blame] | 18 | #include "qapi/qmp/qerror.h" |
| 19 | #include "qapi/visitor.h" |
| 20 | #include "qapi/visitor-impl.h" |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 21 | #include "trace.h" |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 22 | |
Markus Armbruster | ed29bb2 | 2021-10-25 06:24:03 +0200 | [diff] [blame] | 23 | /* Zero-initialization must result in default policy */ |
| 24 | QEMU_BUILD_BUG_ON(COMPAT_POLICY_INPUT_ACCEPT || COMPAT_POLICY_OUTPUT_ACCEPT); |
| 25 | |
| 26 | |
Eric Blake | 3b098d5 | 2016-06-09 10:48:43 -0600 | [diff] [blame] | 27 | void visit_complete(Visitor *v, void *opaque) |
| 28 | { |
| 29 | assert(v->type != VISITOR_OUTPUT || v->complete); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 30 | trace_visit_complete(v, opaque); |
Eric Blake | 3b098d5 | 2016-06-09 10:48:43 -0600 | [diff] [blame] | 31 | if (v->complete) { |
| 32 | v->complete(v, opaque); |
| 33 | } |
| 34 | } |
| 35 | |
Eric Blake | 2c0ef9f | 2016-06-09 10:48:35 -0600 | [diff] [blame] | 36 | void visit_free(Visitor *v) |
| 37 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 38 | trace_visit_free(v); |
Eric Blake | 2c0ef9f | 2016-06-09 10:48:35 -0600 | [diff] [blame] | 39 | if (v) { |
| 40 | v->free(v); |
| 41 | } |
| 42 | } |
| 43 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 44 | bool visit_start_struct(Visitor *v, const char *name, void **obj, |
Eric Blake | 337283d | 2016-01-29 06:48:57 -0700 | [diff] [blame] | 45 | size_t size, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 46 | { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 47 | bool ok; |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 48 | |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 49 | trace_visit_start_struct(v, name, obj, size); |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 50 | if (obj) { |
| 51 | assert(size); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 52 | assert(!(v->type & VISITOR_OUTPUT) || *obj); |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 53 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 54 | ok = v->start_struct(v, name, obj, size, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 55 | if (obj && (v->type & VISITOR_INPUT)) { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 56 | assert(ok != !*obj); |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 57 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 58 | return ok; |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 59 | } |
| 60 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 61 | bool visit_check_struct(Visitor *v, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 62 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 63 | trace_visit_check_struct(v); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 64 | return v->check_struct ? v->check_struct(v, errp) : true; |
Eric Blake | 15c2f66 | 2016-04-28 15:45:27 -0600 | [diff] [blame] | 65 | } |
| 66 | |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 67 | void visit_end_struct(Visitor *v, void **obj) |
Eric Blake | 15c2f66 | 2016-04-28 15:45:27 -0600 | [diff] [blame] | 68 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 69 | trace_visit_end_struct(v, obj); |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 70 | v->end_struct(v, obj); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 71 | } |
| 72 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 73 | bool visit_start_list(Visitor *v, const char *name, GenericList **list, |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 74 | size_t size, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 75 | { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 76 | bool ok; |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 77 | |
| 78 | assert(!list || size >= sizeof(GenericList)); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 79 | trace_visit_start_list(v, name, list, size); |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 80 | ok = v->start_list(v, name, list, size, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 81 | if (list && (v->type & VISITOR_INPUT)) { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 82 | assert(ok || !*list); |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 83 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 84 | return ok; |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 85 | } |
| 86 | |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 87 | GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 88 | { |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 89 | assert(tail && size >= sizeof(GenericList)); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 90 | trace_visit_next_list(v, tail, size); |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 91 | return v->next_list(v, tail, size); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 92 | } |
| 93 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 94 | bool visit_check_list(Visitor *v, Error **errp) |
Markus Armbruster | a4a1c70 | 2017-03-03 13:32:45 +0100 | [diff] [blame] | 95 | { |
| 96 | trace_visit_check_list(v); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 97 | return v->check_list ? v->check_list(v, errp) : true; |
Markus Armbruster | a4a1c70 | 2017-03-03 13:32:45 +0100 | [diff] [blame] | 98 | } |
| 99 | |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 100 | void visit_end_list(Visitor *v, void **obj) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 101 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 102 | trace_visit_end_list(v, obj); |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 103 | v->end_list(v, obj); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 104 | } |
| 105 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 106 | bool visit_start_alternate(Visitor *v, const char *name, |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 107 | GenericAlternate **obj, size_t size, |
Marc-André Lureau | 60390d2 | 2017-06-07 20:35:59 +0400 | [diff] [blame] | 108 | Error **errp) |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 109 | { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 110 | bool ok; |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 111 | |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 112 | assert(obj && size >= sizeof(GenericAlternate)); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 113 | assert(!(v->type & VISITOR_OUTPUT) || *obj); |
Marc-André Lureau | 60390d2 | 2017-06-07 20:35:59 +0400 | [diff] [blame] | 114 | trace_visit_start_alternate(v, name, obj, size); |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 115 | if (!v->start_alternate) { |
| 116 | assert(!(v->type & VISITOR_INPUT)); |
| 117 | return true; |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 118 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 119 | ok = v->start_alternate(v, name, obj, size, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 120 | if (v->type & VISITOR_INPUT) { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 121 | assert(ok != !*obj); |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 122 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 123 | return ok; |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 126 | void visit_end_alternate(Visitor *v, void **obj) |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 127 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 128 | trace_visit_end_alternate(v, obj); |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 129 | if (v->end_alternate) { |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 130 | v->end_alternate(v, obj); |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 131 | } |
| 132 | } |
| 133 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 134 | bool visit_optional(Visitor *v, const char *name, bool *present) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 135 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 136 | trace_visit_optional(v, name, present); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 137 | if (v->optional) { |
Eric Blake | 0b2a0d6 | 2016-01-29 06:48:56 -0700 | [diff] [blame] | 138 | v->optional(v, name, present); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 139 | } |
Eric Blake | 29637a6 | 2015-12-01 22:20:53 -0700 | [diff] [blame] | 140 | return *present; |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 141 | } |
| 142 | |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 143 | bool visit_policy_reject(Visitor *v, const char *name, |
| 144 | unsigned special_features, Error **errp) |
Markus Armbruster | db29164 | 2021-03-18 16:55:18 +0100 | [diff] [blame] | 145 | { |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 146 | trace_visit_policy_reject(v, name); |
| 147 | if (v->policy_reject) { |
| 148 | return v->policy_reject(v, name, special_features, errp); |
Markus Armbruster | db29164 | 2021-03-18 16:55:18 +0100 | [diff] [blame] | 149 | } |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 150 | return false; |
Markus Armbruster | db29164 | 2021-03-18 16:55:18 +0100 | [diff] [blame] | 151 | } |
| 152 | |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 153 | bool visit_policy_skip(Visitor *v, const char *name, |
| 154 | unsigned special_features) |
Markus Armbruster | 91fa93e | 2021-03-18 16:55:11 +0100 | [diff] [blame] | 155 | { |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 156 | trace_visit_policy_skip(v, name); |
| 157 | if (v->policy_skip) { |
| 158 | return v->policy_skip(v, name, special_features); |
Markus Armbruster | 91fa93e | 2021-03-18 16:55:11 +0100 | [diff] [blame] | 159 | } |
Markus Armbruster | a130728 | 2021-10-28 12:25:16 +0200 | [diff] [blame] | 160 | return false; |
Markus Armbruster | 91fa93e | 2021-03-18 16:55:11 +0100 | [diff] [blame] | 161 | } |
| 162 | |
Markus Armbruster | ed29bb2 | 2021-10-25 06:24:03 +0200 | [diff] [blame] | 163 | void visit_set_policy(Visitor *v, CompatPolicy *policy) |
| 164 | { |
| 165 | v->compat_policy = *policy; |
| 166 | } |
| 167 | |
Eric Blake | 68ab47e | 2016-04-28 15:45:32 -0600 | [diff] [blame] | 168 | bool visit_is_input(Visitor *v) |
| 169 | { |
| 170 | return v->type == VISITOR_INPUT; |
| 171 | } |
| 172 | |
Markus Armbruster | 8e08bf4 | 2020-04-24 10:43:29 +0200 | [diff] [blame] | 173 | bool visit_is_dealloc(Visitor *v) |
| 174 | { |
| 175 | return v->type == VISITOR_DEALLOC; |
| 176 | } |
| 177 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 178 | bool visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 179 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 180 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 181 | trace_visit_type_int(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 182 | return v->type_int64(v, name, obj, errp); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 183 | } |
| 184 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 185 | static bool visit_type_uintN(Visitor *v, uint64_t *obj, const char *name, |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 186 | uint64_t max, const char *type, Error **errp) |
| 187 | { |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 188 | uint64_t value = *obj; |
| 189 | |
Markus Armbruster | faad584 | 2020-04-24 10:43:32 +0200 | [diff] [blame] | 190 | assert(v->type == VISITOR_INPUT || value <= max); |
| 191 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 192 | if (!v->type_uint64(v, name, &value, errp)) { |
| 193 | return false; |
| 194 | } |
| 195 | if (value > max) { |
Markus Armbruster | faad584 | 2020-04-24 10:43:32 +0200 | [diff] [blame] | 196 | assert(v->type == VISITOR_INPUT); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 197 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, |
| 198 | name ? name : "null", type); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 199 | return false; |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 200 | } |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 201 | *obj = value; |
| 202 | return true; |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 203 | } |
| 204 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 205 | bool visit_type_uint8(Visitor *v, const char *name, uint8_t *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 206 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 207 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 208 | uint64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 209 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 210 | |
| 211 | trace_visit_type_uint8(v, name, obj); |
| 212 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 213 | ok = visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 214 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 215 | return ok; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 216 | } |
| 217 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 218 | bool visit_type_uint16(Visitor *v, const char *name, uint16_t *obj, |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 219 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 220 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 221 | uint64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 222 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 223 | |
| 224 | trace_visit_type_uint16(v, name, obj); |
| 225 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 226 | ok = visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 227 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 228 | return ok; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 229 | } |
| 230 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 231 | bool visit_type_uint32(Visitor *v, const char *name, uint32_t *obj, |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 232 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 233 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 234 | uint64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 235 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 236 | |
| 237 | trace_visit_type_uint32(v, name, obj); |
| 238 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 239 | ok = visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 240 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 241 | return ok; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 242 | } |
| 243 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 244 | bool visit_type_uint64(Visitor *v, const char *name, uint64_t *obj, |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 245 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 246 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 247 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 248 | trace_visit_type_uint64(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 249 | return v->type_uint64(v, name, obj, errp); |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 250 | } |
| 251 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 252 | static bool visit_type_intN(Visitor *v, int64_t *obj, const char *name, |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 253 | int64_t min, int64_t max, const char *type, |
| 254 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 255 | { |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 256 | int64_t value = *obj; |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 257 | |
Markus Armbruster | faad584 | 2020-04-24 10:43:32 +0200 | [diff] [blame] | 258 | assert(v->type == VISITOR_INPUT || (value >= min && value <= max)); |
| 259 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 260 | if (!v->type_int64(v, name, &value, errp)) { |
| 261 | return false; |
| 262 | } |
| 263 | if (value < min || value > max) { |
Markus Armbruster | faad584 | 2020-04-24 10:43:32 +0200 | [diff] [blame] | 264 | assert(v->type == VISITOR_INPUT); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 265 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, |
| 266 | name ? name : "null", type); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 267 | return false; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 268 | } |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 269 | *obj = value; |
| 270 | return true; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 271 | } |
| 272 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 273 | bool visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp) |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 274 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 275 | int64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 276 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 277 | |
| 278 | trace_visit_type_int8(v, name, obj); |
| 279 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 280 | ok = visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 281 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 282 | return ok; |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 283 | } |
| 284 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 285 | bool visit_type_int16(Visitor *v, const char *name, int16_t *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 286 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 287 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 288 | int64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 289 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 290 | |
| 291 | trace_visit_type_int16(v, name, obj); |
| 292 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 293 | ok = visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", |
| 294 | errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 295 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 296 | return ok; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 297 | } |
| 298 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 299 | bool visit_type_int32(Visitor *v, const char *name, int32_t *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 300 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 301 | { |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 302 | int64_t value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 303 | bool ok; |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 304 | |
| 305 | trace_visit_type_int32(v, name, obj); |
| 306 | value = *obj; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 307 | ok = visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", |
| 308 | errp); |
Eric Blake | 04e070d | 2016-01-29 06:48:51 -0700 | [diff] [blame] | 309 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 310 | return ok; |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 311 | } |
| 312 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 313 | bool visit_type_int64(Visitor *v, const char *name, int64_t *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 314 | Error **errp) |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 315 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 316 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 317 | trace_visit_type_int64(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 318 | return v->type_int64(v, name, obj, errp); |
Michael Roth | 4e27e81 | 2011-08-25 10:44:50 -0500 | [diff] [blame] | 319 | } |
| 320 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 321 | bool visit_type_size(Visitor *v, const char *name, uint64_t *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 322 | Error **errp) |
Laszlo Ersek | 092705d | 2012-07-17 16:17:07 +0200 | [diff] [blame] | 323 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 324 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 325 | trace_visit_type_size(v, name, obj); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 326 | if (v->type_size) { |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 327 | return v->type_size(v, name, obj, errp); |
Laszlo Ersek | 092705d | 2012-07-17 16:17:07 +0200 | [diff] [blame] | 328 | } |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 329 | return v->type_uint64(v, name, obj, errp); |
Laszlo Ersek | 092705d | 2012-07-17 16:17:07 +0200 | [diff] [blame] | 330 | } |
| 331 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 332 | bool visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 333 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 334 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 335 | trace_visit_type_bool(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 336 | return v->type_bool(v, name, obj, errp); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 337 | } |
| 338 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 339 | bool visit_type_str(Visitor *v, const char *name, char **obj, Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 340 | { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 341 | bool ok; |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 342 | |
| 343 | assert(obj); |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 344 | /* TODO: Fix callers to not pass NULL when they mean "", so that we |
| 345 | * can enable: |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 346 | assert(!(v->type & VISITOR_OUTPUT) || *obj); |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 347 | */ |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 348 | trace_visit_type_str(v, name, obj); |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 349 | ok = v->type_str(v, name, obj, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 350 | if (v->type & VISITOR_INPUT) { |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 351 | assert(ok != !*obj); |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 352 | } |
Markus Armbruster | 7b3cb80 | 2020-07-07 18:06:09 +0200 | [diff] [blame] | 353 | return ok; |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 354 | } |
| 355 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 356 | bool visit_type_number(Visitor *v, const char *name, double *obj, |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 357 | Error **errp) |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 358 | { |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 359 | assert(obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 360 | trace_visit_type_number(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 361 | return v->type_number(v, name, obj, errp); |
Michael Roth | 2345c77 | 2011-07-19 14:50:32 -0500 | [diff] [blame] | 362 | } |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 363 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 364 | bool visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp) |
Markus Armbruster | 28770e0 | 2015-09-16 13:06:24 +0200 | [diff] [blame] | 365 | { |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 366 | bool ok; |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 367 | |
| 368 | assert(obj); |
Eric Blake | adfb264 | 2016-04-28 15:45:20 -0600 | [diff] [blame] | 369 | assert(v->type != VISITOR_OUTPUT || *obj); |
Daniel P. Berrange | ebfd93b | 2016-09-30 15:45:26 +0100 | [diff] [blame] | 370 | trace_visit_type_any(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 371 | ok = v->type_any(v, name, obj, errp); |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 372 | if (v->type == VISITOR_INPUT) { |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 373 | assert(ok != !*obj); |
Eric Blake | e58d695 | 2016-04-28 15:45:10 -0600 | [diff] [blame] | 374 | } |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 375 | return ok; |
Markus Armbruster | 28770e0 | 2015-09-16 13:06:24 +0200 | [diff] [blame] | 376 | } |
| 377 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 378 | bool visit_type_null(Visitor *v, const char *name, QNull **obj, |
Markus Armbruster | d2f95f4 | 2017-06-26 18:22:59 +0200 | [diff] [blame] | 379 | Error **errp) |
Eric Blake | 3bc97fd | 2016-04-28 15:45:22 -0600 | [diff] [blame] | 380 | { |
Markus Armbruster | d2f95f4 | 2017-06-26 18:22:59 +0200 | [diff] [blame] | 381 | trace_visit_type_null(v, name, obj); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 382 | return v->type_null(v, name, obj, errp); |
Eric Blake | 3bc97fd | 2016-04-28 15:45:22 -0600 | [diff] [blame] | 383 | } |
| 384 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 385 | static bool output_type_enum(Visitor *v, const char *name, int *obj, |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 386 | const QEnumLookup *lookup, Error **errp) |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 387 | { |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 388 | int value = *obj; |
| 389 | char *enum_str; |
| 390 | |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 391 | enum_str = (char *)qapi_enum_lookup(lookup, value); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 392 | return visit_type_str(v, name, &enum_str, errp); |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 393 | } |
| 394 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 395 | static bool input_type_enum(Visitor *v, const char *name, int *obj, |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 396 | const QEnumLookup *lookup, Error **errp) |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 397 | { |
Markus Armbruster | 113e47a | 2017-08-24 10:46:05 +0200 | [diff] [blame] | 398 | int64_t value; |
Markus Armbruster | aa23704 | 2021-10-25 06:24:04 +0200 | [diff] [blame] | 399 | g_autofree char *enum_str = NULL; |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 400 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 401 | if (!visit_type_str(v, name, &enum_str, errp)) { |
| 402 | return false; |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 403 | } |
| 404 | |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 405 | value = qapi_enum_parse(lookup, enum_str, -1, NULL); |
Markus Armbruster | 113e47a | 2017-08-24 10:46:05 +0200 | [diff] [blame] | 406 | if (value < 0) { |
Markus Armbruster | ea29331 | 2021-10-20 20:02:31 +0200 | [diff] [blame] | 407 | error_setg(errp, "Parameter '%s' does not accept value '%s'", |
| 408 | name ? name : "null", enum_str); |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 409 | return false; |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 410 | } |
| 411 | |
Markus Armbruster | c868876 | 2021-10-28 12:25:18 +0200 | [diff] [blame] | 412 | if (lookup->special_features |
Markus Armbruster | 7ce5fc6 | 2021-10-28 12:25:19 +0200 | [diff] [blame] | 413 | && !compat_policy_input_ok(lookup->special_features[value], |
| 414 | &v->compat_policy, |
| 415 | ERROR_CLASS_GENERIC_ERROR, |
| 416 | "value", enum_str, errp)) { |
| 417 | return false; |
Markus Armbruster | aa23704 | 2021-10-25 06:24:04 +0200 | [diff] [blame] | 418 | } |
| 419 | |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 420 | *obj = value; |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 421 | return true; |
Paolo Bonzini | 0f71a1e | 2012-02-09 09:11:52 +0100 | [diff] [blame] | 422 | } |
Eric Blake | 983f52d | 2016-04-28 15:45:09 -0600 | [diff] [blame] | 423 | |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 424 | bool visit_type_enum(Visitor *v, const char *name, int *obj, |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 425 | const QEnumLookup *lookup, Error **errp) |
Eric Blake | 983f52d | 2016-04-28 15:45:09 -0600 | [diff] [blame] | 426 | { |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 427 | assert(obj && lookup); |
Stefan Hajnoczi | 6514532 | 2017-01-26 17:16:12 +0000 | [diff] [blame] | 428 | trace_visit_type_enum(v, name, obj); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 429 | switch (v->type) { |
| 430 | case VISITOR_INPUT: |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 431 | return input_type_enum(v, name, obj, lookup, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 432 | case VISITOR_OUTPUT: |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 433 | return output_type_enum(v, name, obj, lookup, errp); |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 434 | case VISITOR_CLONE: |
| 435 | /* nothing further to do, scalar value was already copied by |
| 436 | * g_memdup() during visit_start_*() */ |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 437 | return true; |
Eric Blake | a15fcc3 | 2016-06-09 10:48:44 -0600 | [diff] [blame] | 438 | case VISITOR_DEALLOC: |
| 439 | /* nothing to deallocate for a scalar */ |
Markus Armbruster | 012d4c9 | 2020-07-07 18:05:45 +0200 | [diff] [blame] | 440 | return true; |
| 441 | default: |
| 442 | abort(); |
Eric Blake | 983f52d | 2016-04-28 15:45:09 -0600 | [diff] [blame] | 443 | } |
| 444 | } |