]>
git.proxmox.com Git - mirror_qemu.git/blob - scripts/qapi-visit.py
2 # QAPI visitor generator
4 # Copyright IBM, Corp. 2011
5 # Copyright (C) 2014-2015 Red Hat, Inc.
8 # Anthony Liguori <aliguori@us.ibm.com>
9 # Michael Roth <mdroth@linux.vnet.ibm.com>
10 # Markus Armbruster <armbru@redhat.com>
12 # This work is licensed under the terms of the GNU GPL, version 2.
13 # See the COPYING file in the top-level directory.
15 from ordereddict
import OrderedDict
19 implicit_structs_seen
= set()
20 struct_fields_seen
= set()
22 def generate_visit_implicit_struct(type):
23 if type in implicit_structs_seen
:
25 implicit_structs_seen
.add(type)
27 if type not in struct_fields_seen
:
28 # Need a forward declaration
31 static void visit_type_%(c_type)s_fields(Visitor *m, %(c_type)s **obj, Error **errp);
33 c_type
=type_name(type))
37 static void visit_type_implicit_%(c_type)s(Visitor *m, %(c_type)s **obj, Error **errp)
41 visit_start_implicit_struct(m, (void **)obj, sizeof(%(c_type)s), &err);
43 visit_type_%(c_type)s_fields(m, obj, errp);
44 visit_end_implicit_struct(m, &err);
46 error_propagate(errp, err);
49 c_type
=type_name(type))
52 def generate_visit_struct_fields(name
, members
, base
= None):
53 struct_fields_seen
.add(name
)
58 ret
+= generate_visit_implicit_struct(base
)
62 static void visit_type_%(name)s_fields(Visitor *m, %(name)s **obj, Error **errp)
71 visit_type_implicit_%(type)s(m, &(*obj)->%(c_name)s, &err);
76 type=type_name(base
), c_name
=c_name('base'))
78 for argname
, argentry
, optional
in parse_args(members
):
81 visit_optional(m, &(*obj)->has_%(c_name)s, "%(name)s", &err);
82 if (!err && (*obj)->has_%(c_name)s) {
84 c_name
=c_name(argname
), name
=argname
)
88 visit_type_%(type)s(m, &(*obj)->%(c_name)s, "%(name)s", &err);
90 type=type_name(argentry
), c_name
=c_name(argname
),
105 if re
.search('^ *goto out\\;', ret
, re
.MULTILINE
):
111 error_propagate(errp, err);
117 def generate_visit_struct_body(name
):
121 visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
124 visit_type_%(c_name)s_fields(m, obj, errp);
126 visit_end_struct(m, &err);
128 error_propagate(errp, err);
130 name
=name
, c_name
=c_name(name
))
134 def generate_visit_struct(expr
):
136 name
= expr
['struct']
137 members
= expr
['data']
138 base
= expr
.get('base')
140 ret
= generate_visit_struct_fields(name
, members
, base
)
144 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
149 ret
+= generate_visit_struct_body(name
)
156 def generate_visit_list(name
):
159 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp)
162 GenericList *i, **prev;
164 visit_start_list(m, name, &err);
169 for (prev = (GenericList **)obj;
170 !err && (i = visit_next_list(m, prev, &err)) != NULL;
172 %(name)sList *native_i = (%(name)sList *)i;
173 visit_type_%(name)s(m, &native_i->value, NULL, &err);
176 error_propagate(errp, err);
178 visit_end_list(m, &err);
180 error_propagate(errp, err);
183 name
=type_name(name
))
185 def generate_visit_enum(name
):
188 void visit_type_%(c_name)s(Visitor *m, %(c_name)s *obj, const char *name, Error **errp)
190 visit_type_enum(m, (int *)obj, %(c_name)s_lookup, "%(name)s", name, errp);
193 c_name
=c_name(name
), name
=name
)
195 def generate_visit_alternate(name
, members
):
198 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
202 visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err);
206 visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err);
210 switch ((*obj)->kind) {
214 # For alternate, always use the default enum type automatically generated
216 disc_type
= c_name(name
) + 'Kind'
219 assert (members
[key
] in builtin_types
.keys()
220 or find_struct(members
[key
])
221 or find_union(members
[key
])
222 or find_enum(members
[key
])), "Invalid alternate member"
224 enum_full_value
= c_enum_const(disc_type
, key
)
226 case %(enum_full_value)s:
227 visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
230 enum_full_value
= enum_full_value
,
231 c_type
= type_name(members
[key
]),
232 c_name
= c_name(key
))
239 error_propagate(errp, err);
241 visit_end_implicit_struct(m, &err);
243 error_propagate(errp, err);
250 def generate_visit_union(expr
):
253 members
= expr
['data']
255 base
= expr
.get('base')
256 discriminator
= expr
.get('discriminator')
258 enum_define
= discriminator_find_enum_define(expr
)
260 # Use the enum type as discriminator
262 disc_type
= c_name(enum_define
['enum_name'])
264 # There will always be a discriminator in the C switch code, by default
265 # it is an enum type generated silently
266 ret
= generate_visit_enum(name
+ 'Kind')
267 disc_type
= c_name(name
) + 'Kind'
271 base_fields
= find_struct(base
)['data'].copy()
272 del base_fields
[discriminator
]
273 ret
+= generate_visit_struct_fields(name
, base_fields
)
277 ret
+= generate_visit_implicit_struct(members
[key
])
281 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
285 visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
291 c_name
=c_name(name
), name
=name
)
295 visit_type_%(name)s_fields(m, obj, &err);
302 if not discriminator
:
307 disc_key
= discriminator
309 visit_type_%(disc_type)s(m, &(*obj)->%(c_tag)s, "%(disc_key)s", &err);
313 if (!visit_start_union(m, !!(*obj)->data, &err) || err) {
316 switch ((*obj)->%(c_tag)s) {
318 disc_type
= disc_type
,
323 if not discriminator
:
324 fmt
= 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);'
326 fmt
= 'visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);'
328 enum_full_value
= c_enum_const(disc_type
, key
)
330 case %(enum_full_value)s:
334 enum_full_value
= enum_full_value
,
335 c_type
=type_name(members
[key
]),
343 error_propagate(errp, err);
345 visit_end_union(m, !!(*obj)->data, &err);
346 error_propagate(errp, err);
349 visit_end_struct(m, &err);
351 error_propagate(errp, err);
357 def generate_declaration(name
, builtin_type
=False):
363 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp);
368 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
374 def generate_enum_declaration(name
):
376 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
382 def generate_decl_enum(name
):
385 void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp);
391 (input_file
, output_dir
, do_c
, do_h
, prefix
, opts
) = \
392 parse_command_line("b", ["builtins"])
395 if o
in ("-b", "--builtins"):
400 * schema-defined QAPI visitor functions
402 * Copyright IBM, Corp. 2011
405 * Anthony Liguori <aliguori@us.ibm.com>
407 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
408 * See the COPYING.LIB file in the top-level directory.
414 * schema-defined QAPI visitor functions
416 * Copyright IBM, Corp. 2011
419 * Anthony Liguori <aliguori@us.ibm.com>
421 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
422 * See the COPYING.LIB file in the top-level directory.
427 (fdef
, fdecl
) = open_output(output_dir
, do_c
, do_h
, prefix
,
428 'qapi-visit.c', 'qapi-visit.h',
429 c_comment
, h_comment
)
432 #include "qemu-common.h"
433 #include "%(prefix)sqapi-visit.h"
437 fdecl
.write(mcgen('''
438 #include "qapi/visitor.h"
439 #include "%(prefix)sqapi-types.h"
444 exprs
= parse_schema(input_file
)
446 # to avoid header dependency hell, we always generate declarations
447 # for built-in types in our header files and simply guard them
448 fdecl
.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
449 for typename
in builtin_types
.keys():
450 fdecl
.write(generate_declaration(typename
, builtin_type
=True))
451 fdecl
.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
453 # ...this doesn't work for cases where we link in multiple objects that
454 # have the functions defined, so we use -b option to provide control
457 for typename
in builtin_types
.keys():
458 fdef
.write(generate_visit_list(typename
))
461 if expr
.has_key('struct'):
462 ret
= generate_visit_struct(expr
)
463 ret
+= generate_visit_list(expr
['struct'])
466 ret
= generate_declaration(expr
['struct'])
468 elif expr
.has_key('union'):
469 ret
= generate_visit_union(expr
)
470 ret
+= generate_visit_list(expr
['union'])
473 enum_define
= discriminator_find_enum_define(expr
)
476 ret
= generate_decl_enum('%sKind' % expr
['union'])
477 ret
+= generate_declaration(expr
['union'])
479 elif expr
.has_key('alternate'):
480 ret
= generate_visit_alternate(expr
['alternate'], expr
['data'])
481 ret
+= generate_visit_list(expr
['alternate'])
484 ret
= generate_decl_enum('%sKind' % expr
['alternate'])
485 ret
+= generate_declaration(expr
['alternate'])
487 elif expr
.has_key('enum'):
488 ret
= generate_visit_list(expr
['enum'])
489 ret
+= generate_visit_enum(expr
['enum'])
492 ret
= generate_decl_enum(expr
['enum'])
493 ret
+= generate_enum_declaration(expr
['enum'])
496 close_output(fdef
, fdecl
)