target/riscv: vmfirst find-first-set mask bit
[qemu.git] / qapi / qapi-clone-visitor.c
1 /*
2 * Copy one QAPI object to another
3 *
4 * Copyright (C) 2016 Red Hat, Inc.
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 *
9 */
10
11 #include "qemu/osdep.h"
12 #include "qapi/clone-visitor.h"
13 #include "qapi/visitor-impl.h"
14 #include "qapi/error.h"
15 #include "qapi/qmp/qnull.h"
16
17 struct QapiCloneVisitor {
18 Visitor visitor;
19 size_t depth;
20 };
21
22 static QapiCloneVisitor *to_qcv(Visitor *v)
23 {
24 return container_of(v, QapiCloneVisitor, visitor);
25 }
26
27 static void qapi_clone_start_struct(Visitor *v, const char *name, void **obj,
28 size_t size, Error **errp)
29 {
30 QapiCloneVisitor *qcv = to_qcv(v);
31
32 if (!obj) {
33 assert(qcv->depth);
34 /* Only possible when visiting an alternate's object
35 * branch. Nothing further to do here, since the earlier
36 * visit_start_alternate() already copied memory. */
37 return;
38 }
39
40 *obj = g_memdup(*obj, size);
41 qcv->depth++;
42 }
43
44 static void qapi_clone_end(Visitor *v, void **obj)
45 {
46 QapiCloneVisitor *qcv = to_qcv(v);
47
48 assert(qcv->depth);
49 if (obj) {
50 qcv->depth--;
51 }
52 }
53
54 static void qapi_clone_start_list(Visitor *v, const char *name,
55 GenericList **listp, size_t size,
56 Error **errp)
57 {
58 qapi_clone_start_struct(v, name, (void **)listp, size, errp);
59 }
60
61 static GenericList *qapi_clone_next_list(Visitor *v, GenericList *tail,
62 size_t size)
63 {
64 QapiCloneVisitor *qcv = to_qcv(v);
65
66 assert(qcv->depth);
67 /* Unshare the tail of the list cloned by g_memdup() */
68 tail->next = g_memdup(tail->next, size);
69 return tail->next;
70 }
71
72 static void qapi_clone_start_alternate(Visitor *v, const char *name,
73 GenericAlternate **obj, size_t size,
74 Error **errp)
75 {
76 qapi_clone_start_struct(v, name, (void **)obj, size, errp);
77 }
78
79 static void qapi_clone_type_int64(Visitor *v, const char *name, int64_t *obj,
80 Error **errp)
81 {
82 QapiCloneVisitor *qcv = to_qcv(v);
83
84 assert(qcv->depth);
85 /* Value was already cloned by g_memdup() */
86 }
87
88 static void qapi_clone_type_uint64(Visitor *v, const char *name,
89 uint64_t *obj, Error **errp)
90 {
91 QapiCloneVisitor *qcv = to_qcv(v);
92
93 assert(qcv->depth);
94 /* Value was already cloned by g_memdup() */
95 }
96
97 static void qapi_clone_type_bool(Visitor *v, const char *name, bool *obj,
98 Error **errp)
99 {
100 QapiCloneVisitor *qcv = to_qcv(v);
101
102 assert(qcv->depth);
103 /* Value was already cloned by g_memdup() */
104 }
105
106 static void qapi_clone_type_str(Visitor *v, const char *name, char **obj,
107 Error **errp)
108 {
109 QapiCloneVisitor *qcv = to_qcv(v);
110
111 assert(qcv->depth);
112 /*
113 * Pointer was already cloned by g_memdup; create fresh copy.
114 * Note that as long as qobject-output-visitor accepts NULL instead of
115 * "", then we must do likewise. However, we want to obey the
116 * input visitor semantics of never producing NULL when the empty
117 * string is intended.
118 */
119 *obj = g_strdup(*obj ?: "");
120 }
121
122 static void qapi_clone_type_number(Visitor *v, const char *name, double *obj,
123 Error **errp)
124 {
125 QapiCloneVisitor *qcv = to_qcv(v);
126
127 assert(qcv->depth);
128 /* Value was already cloned by g_memdup() */
129 }
130
131 static void qapi_clone_type_null(Visitor *v, const char *name, QNull **obj,
132 Error **errp)
133 {
134 QapiCloneVisitor *qcv = to_qcv(v);
135
136 assert(qcv->depth);
137 *obj = qnull();
138 }
139
140 static void qapi_clone_free(Visitor *v)
141 {
142 g_free(v);
143 }
144
145 static Visitor *qapi_clone_visitor_new(void)
146 {
147 QapiCloneVisitor *v;
148
149 v = g_malloc0(sizeof(*v));
150
151 v->visitor.type = VISITOR_CLONE;
152 v->visitor.start_struct = qapi_clone_start_struct;
153 v->visitor.end_struct = qapi_clone_end;
154 v->visitor.start_list = qapi_clone_start_list;
155 v->visitor.next_list = qapi_clone_next_list;
156 v->visitor.end_list = qapi_clone_end;
157 v->visitor.start_alternate = qapi_clone_start_alternate;
158 v->visitor.end_alternate = qapi_clone_end;
159 v->visitor.type_int64 = qapi_clone_type_int64;
160 v->visitor.type_uint64 = qapi_clone_type_uint64;
161 v->visitor.type_bool = qapi_clone_type_bool;
162 v->visitor.type_str = qapi_clone_type_str;
163 v->visitor.type_number = qapi_clone_type_number;
164 v->visitor.type_null = qapi_clone_type_null;
165 v->visitor.free = qapi_clone_free;
166
167 return &v->visitor;
168 }
169
170 void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
171 void **, Error **))
172 {
173 Visitor *v;
174 void *dst = (void *) src; /* Cast away const */
175
176 if (!src) {
177 return NULL;
178 }
179
180 v = qapi_clone_visitor_new();
181 visit_type(v, NULL, &dst, &error_abort);
182 visit_free(v);
183 return dst;
184 }
185
186 void qapi_clone_members(void *dst, const void *src, size_t sz,
187 void (*visit_type_members)(Visitor *, void *,
188 Error **))
189 {
190 Visitor *v;
191
192 v = qapi_clone_visitor_new();
193 memcpy(dst, src, sz);
194 to_qcv(v)->depth++;
195 visit_type_members(v, dst, &error_abort);
196 visit_free(v);
197 }