]> Git Repo - qemu.git/blob - scripts/qapi-visit.py
migration: remove support for non-iovec based write handlers
[qemu.git] / scripts / qapi-visit.py
1 #
2 # QAPI visitor generator
3 #
4 # Copyright IBM, Corp. 2011
5 # Copyright (C) 2014-2016 Red Hat, Inc.
6 #
7 # Authors:
8 #  Anthony Liguori <[email protected]>
9 #  Michael Roth    <[email protected]>
10 #  Markus Armbruster <[email protected]>
11 #
12 # This work is licensed under the terms of the GNU GPL, version 2.
13 # See the COPYING file in the top-level directory.
14
15 from qapi import *
16 import re
17
18
19 def gen_visit_decl(name, scalar=False):
20     c_type = c_name(name) + ' *'
21     if not scalar:
22         c_type += '*'
23     return mcgen('''
24 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_type)sobj, Error **errp);
25 ''',
26                  c_name=c_name(name), c_type=c_type)
27
28
29 def gen_visit_members_decl(name):
30     return mcgen('''
31
32 void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp);
33 ''',
34                  c_name=c_name(name))
35
36
37 def gen_visit_object_members(name, base, members, variants):
38     ret = mcgen('''
39
40 void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp)
41 {
42     Error *err = NULL;
43
44 ''',
45                 c_name=c_name(name))
46
47     if base:
48         ret += mcgen('''
49     visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, &err);
50 ''',
51                      c_type=base.c_name())
52         ret += gen_err_check()
53
54     for memb in members:
55         if memb.optional:
56             ret += mcgen('''
57     if (visit_optional(v, "%(name)s", &obj->has_%(c_name)s)) {
58 ''',
59                          name=memb.name, c_name=c_name(memb.name))
60             push_indent()
61         ret += mcgen('''
62     visit_type_%(c_type)s(v, "%(name)s", &obj->%(c_name)s, &err);
63 ''',
64                      c_type=memb.type.c_name(), name=memb.name,
65                      c_name=c_name(memb.name))
66         ret += gen_err_check()
67         if memb.optional:
68             pop_indent()
69             ret += mcgen('''
70     }
71 ''')
72
73     if variants:
74         ret += mcgen('''
75     switch (obj->%(c_name)s) {
76 ''',
77                      c_name=c_name(variants.tag_member.name))
78
79         for var in variants.variants:
80             ret += mcgen('''
81     case %(case)s:
82         visit_type_%(c_type)s_members(v, &obj->u.%(c_name)s, &err);
83         break;
84 ''',
85                          case=c_enum_const(variants.tag_member.type.name,
86                                            var.name,
87                                            variants.tag_member.type.prefix),
88                          c_type=var.type.c_name(), c_name=c_name(var.name))
89
90         ret += mcgen('''
91     default:
92         abort();
93     }
94 ''')
95
96     # 'goto out' produced for base, for each member, and if variants were
97     # present
98     if base or members or variants:
99         ret += mcgen('''
100
101 out:
102 ''')
103     ret += mcgen('''
104     error_propagate(errp, err);
105 }
106 ''')
107     return ret
108
109
110 def gen_visit_list(name, element_type):
111     return mcgen('''
112
113 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
114 {
115     Error *err = NULL;
116     %(c_name)s *tail;
117     size_t size = sizeof(**obj);
118
119     visit_start_list(v, name, (GenericList **)obj, size, &err);
120     if (err) {
121         goto out;
122     }
123
124     for (tail = *obj; tail;
125          tail = (%(c_name)s *)visit_next_list(v, (GenericList *)tail, size)) {
126         visit_type_%(c_elt_type)s(v, NULL, &tail->value, &err);
127         if (err) {
128             break;
129         }
130     }
131
132     visit_end_list(v);
133     if (err && visit_is_input(v)) {
134         qapi_free_%(c_name)s(*obj);
135         *obj = NULL;
136     }
137 out:
138     error_propagate(errp, err);
139 }
140 ''',
141                  c_name=c_name(name), c_elt_type=element_type.c_name())
142
143
144 def gen_visit_enum(name):
145     return mcgen('''
146
147 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s *obj, Error **errp)
148 {
149     int value = *obj;
150     visit_type_enum(v, name, &value, %(c_name)s_lookup, errp);
151     *obj = value;
152 }
153 ''',
154                  c_name=c_name(name))
155
156
157 def gen_visit_alternate(name, variants):
158     promote_int = 'true'
159     ret = ''
160     for var in variants.variants:
161         if var.type.alternate_qtype() == 'QTYPE_QINT':
162             promote_int = 'false'
163
164     ret += mcgen('''
165
166 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
167 {
168     Error *err = NULL;
169
170     visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
171                           %(promote_int)s, &err);
172     if (err) {
173         goto out;
174     }
175     switch ((*obj)->type) {
176 ''',
177                  c_name=c_name(name), promote_int=promote_int)
178
179     for var in variants.variants:
180         ret += mcgen('''
181     case %(case)s:
182 ''',
183                      case=var.type.alternate_qtype())
184         if isinstance(var.type, QAPISchemaObjectType):
185             ret += mcgen('''
186         visit_start_struct(v, name, NULL, 0, &err);
187         if (err) {
188             break;
189         }
190         visit_type_%(c_type)s_members(v, &(*obj)->u.%(c_name)s, &err);
191         if (!err) {
192             visit_check_struct(v, &err);
193         }
194         visit_end_struct(v);
195 ''',
196                          c_type=var.type.c_name(),
197                          c_name=c_name(var.name))
198         else:
199             ret += mcgen('''
200         visit_type_%(c_type)s(v, name, &(*obj)->u.%(c_name)s, &err);
201 ''',
202                          c_type=var.type.c_name(),
203                          c_name=c_name(var.name))
204         ret += mcgen('''
205         break;
206 ''')
207
208     ret += mcgen('''
209     default:
210         error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
211                    "%(name)s");
212     }
213     visit_end_alternate(v);
214     if (err && visit_is_input(v)) {
215         qapi_free_%(c_name)s(*obj);
216         *obj = NULL;
217     }
218 out:
219     error_propagate(errp, err);
220 }
221 ''',
222                  name=name, c_name=c_name(name))
223
224     return ret
225
226
227 def gen_visit_object(name, base, members, variants):
228     return mcgen('''
229
230 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
231 {
232     Error *err = NULL;
233
234     visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), &err);
235     if (err) {
236         goto out;
237     }
238     if (!*obj) {
239         goto out_obj;
240     }
241     visit_type_%(c_name)s_members(v, *obj, &err);
242     if (err) {
243         goto out_obj;
244     }
245     visit_check_struct(v, &err);
246 out_obj:
247     visit_end_struct(v);
248     if (err && visit_is_input(v)) {
249         qapi_free_%(c_name)s(*obj);
250         *obj = NULL;
251     }
252 out:
253     error_propagate(errp, err);
254 }
255 ''',
256                  c_name=c_name(name))
257
258
259 class QAPISchemaGenVisitVisitor(QAPISchemaVisitor):
260     def __init__(self):
261         self.decl = None
262         self.defn = None
263         self._btin = None
264
265     def visit_begin(self, schema):
266         self.decl = ''
267         self.defn = ''
268         self._btin = guardstart('QAPI_VISIT_BUILTIN')
269
270     def visit_end(self):
271         # To avoid header dependency hell, we always generate
272         # declarations for built-in types in our header files and
273         # simply guard them.  See also do_builtins (command line
274         # option -b).
275         self._btin += guardend('QAPI_VISIT_BUILTIN')
276         self.decl = self._btin + self.decl
277         self._btin = None
278
279     def visit_enum_type(self, name, info, values, prefix):
280         # Special case for our lone builtin enum type
281         # TODO use something cleaner than existence of info
282         if not info:
283             self._btin += gen_visit_decl(name, scalar=True)
284             if do_builtins:
285                 self.defn += gen_visit_enum(name)
286         else:
287             self.decl += gen_visit_decl(name, scalar=True)
288             self.defn += gen_visit_enum(name)
289
290     def visit_array_type(self, name, info, element_type):
291         decl = gen_visit_decl(name)
292         defn = gen_visit_list(name, element_type)
293         if isinstance(element_type, QAPISchemaBuiltinType):
294             self._btin += decl
295             if do_builtins:
296                 self.defn += defn
297         else:
298             self.decl += decl
299             self.defn += defn
300
301     def visit_object_type(self, name, info, base, members, variants):
302         # Nothing to do for the special empty builtin
303         if name == 'q_empty':
304             return
305         self.decl += gen_visit_members_decl(name)
306         self.defn += gen_visit_object_members(name, base, members, variants)
307         # TODO Worth changing the visitor signature, so we could
308         # directly use rather than repeat type.is_implicit()?
309         if not name.startswith('q_'):
310             # only explicit types need an allocating visit
311             self.decl += gen_visit_decl(name)
312             self.defn += gen_visit_object(name, base, members, variants)
313
314     def visit_alternate_type(self, name, info, variants):
315         self.decl += gen_visit_decl(name)
316         self.defn += gen_visit_alternate(name, variants)
317
318 # If you link code generated from multiple schemata, you want only one
319 # instance of the code for built-in types.  Generate it only when
320 # do_builtins, enabled by command line option -b.  See also
321 # QAPISchemaGenVisitVisitor.visit_end().
322 do_builtins = False
323
324 (input_file, output_dir, do_c, do_h, prefix, opts) = \
325     parse_command_line("b", ["builtins"])
326
327 for o, a in opts:
328     if o in ("-b", "--builtins"):
329         do_builtins = True
330
331 c_comment = '''
332 /*
333  * schema-defined QAPI visitor functions
334  *
335  * Copyright IBM, Corp. 2011
336  *
337  * Authors:
338  *  Anthony Liguori   <[email protected]>
339  *
340  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
341  * See the COPYING.LIB file in the top-level directory.
342  *
343  */
344 '''
345 h_comment = '''
346 /*
347  * schema-defined QAPI visitor functions
348  *
349  * Copyright IBM, Corp. 2011
350  *
351  * Authors:
352  *  Anthony Liguori   <[email protected]>
353  *
354  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
355  * See the COPYING.LIB file in the top-level directory.
356  *
357  */
358 '''
359
360 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
361                             'qapi-visit.c', 'qapi-visit.h',
362                             c_comment, h_comment)
363
364 fdef.write(mcgen('''
365 #include "qemu/osdep.h"
366 #include "qemu-common.h"
367 #include "qapi/error.h"
368 #include "%(prefix)sqapi-visit.h"
369 ''',
370                  prefix=prefix))
371
372 fdecl.write(mcgen('''
373 #include "qapi/visitor.h"
374 #include "qapi/qmp/qerror.h"
375 #include "%(prefix)sqapi-types.h"
376
377 ''',
378                   prefix=prefix))
379
380 schema = QAPISchema(input_file)
381 gen = QAPISchemaGenVisitVisitor()
382 schema.visit(gen)
383 fdef.write(gen.defn)
384 fdecl.write(gen.decl)
385
386 close_output(fdef, fdecl)
This page took 0.067777 seconds and 4 git commands to generate.