hw/arm/virt: parameter passing cleanups
[qemu.git] / scripts / qapi-types.py
1 #
2 # QAPI types generator
3 #
4 # Copyright IBM, Corp. 2011
5 # Copyright (c) 2013-2016 Red Hat Inc.
6 #
7 # Authors:
8 # Anthony Liguori <aliguori@us.ibm.com>
9 # Markus Armbruster <armbru@redhat.com>
10 #
11 # This work is licensed under the terms of the GNU GPL, version 2.
12 # See the COPYING file in the top-level directory.
13
14 from qapi import *
15
16
17 # variants must be emitted before their container; track what has already
18 # been output
19 objects_seen = set()
20
21
22 def gen_fwd_object_or_array(name):
23 return mcgen('''
24
25 typedef struct %(c_name)s %(c_name)s;
26 ''',
27 c_name=c_name(name))
28
29
30 def gen_array(name, element_type):
31 return mcgen('''
32
33 struct %(c_name)s {
34 %(c_name)s *next;
35 %(c_type)s value;
36 };
37 ''',
38 c_name=c_name(name), c_type=element_type.c_type())
39
40
41 def gen_struct_members(members):
42 ret = ''
43 for memb in members:
44 if memb.optional:
45 ret += mcgen('''
46 bool has_%(c_name)s;
47 ''',
48 c_name=c_name(memb.name))
49 ret += mcgen('''
50 %(c_type)s %(c_name)s;
51 ''',
52 c_type=memb.type.c_type(), c_name=c_name(memb.name))
53 return ret
54
55
56 def gen_object(name, base, members, variants):
57 if name in objects_seen:
58 return ''
59 objects_seen.add(name)
60
61 ret = ''
62 if variants:
63 for v in variants.variants:
64 if isinstance(v.type, QAPISchemaObjectType):
65 ret += gen_object(v.type.name, v.type.base,
66 v.type.local_members, v.type.variants)
67
68 ret += mcgen('''
69
70 struct %(c_name)s {
71 ''',
72 c_name=c_name(name))
73
74 if base:
75 if not base.is_implicit():
76 ret += mcgen('''
77 /* Members inherited from %(c_name)s: */
78 ''',
79 c_name=base.c_name())
80 ret += gen_struct_members(base.members)
81 if not base.is_implicit():
82 ret += mcgen('''
83 /* Own members: */
84 ''')
85 ret += gen_struct_members(members)
86
87 if variants:
88 ret += gen_variants(variants)
89
90 # Make sure that all structs have at least one member; this avoids
91 # potential issues with attempting to malloc space for zero-length
92 # structs in C, and also incompatibility with C++ (where an empty
93 # struct is size 1).
94 if (not base or base.is_empty()) and not members and not variants:
95 ret += mcgen('''
96 char qapi_dummy_for_empty_struct;
97 ''')
98
99 ret += mcgen('''
100 };
101 ''')
102
103 return ret
104
105
106 def gen_upcast(name, base):
107 # C makes const-correctness ugly. We have to cast away const to let
108 # this function work for both const and non-const obj.
109 return mcgen('''
110
111 static inline %(base)s *qapi_%(c_name)s_base(const %(c_name)s *obj)
112 {
113 return (%(base)s *)obj;
114 }
115 ''',
116 c_name=c_name(name), base=base.c_name())
117
118
119 def gen_variants(variants):
120 ret = mcgen('''
121 union { /* union tag is @%(c_name)s */
122 ''',
123 c_name=c_name(variants.tag_member.name))
124
125 for var in variants.variants:
126 ret += mcgen('''
127 %(c_type)s %(c_name)s;
128 ''',
129 c_type=var.type.c_unboxed_type(),
130 c_name=c_name(var.name))
131
132 ret += mcgen('''
133 } u;
134 ''')
135
136 return ret
137
138
139 def gen_type_cleanup_decl(name):
140 ret = mcgen('''
141
142 void qapi_free_%(c_name)s(%(c_name)s *obj);
143 ''',
144 c_name=c_name(name))
145 return ret
146
147
148 def gen_type_cleanup(name):
149 ret = mcgen('''
150
151 void qapi_free_%(c_name)s(%(c_name)s *obj)
152 {
153 Visitor *v;
154
155 if (!obj) {
156 return;
157 }
158
159 v = qapi_dealloc_visitor_new();
160 visit_type_%(c_name)s(v, NULL, &obj, NULL);
161 visit_free(v);
162 }
163 ''',
164 c_name=c_name(name))
165 return ret
166
167
168 class QAPISchemaGenTypeVisitor(QAPISchemaVisitor):
169 def __init__(self):
170 self.decl = None
171 self.defn = None
172 self._fwdecl = None
173 self._btin = None
174
175 def visit_begin(self, schema):
176 # gen_object() is recursive, ensure it doesn't visit the empty type
177 objects_seen.add(schema.the_empty_object_type.name)
178 self.decl = ''
179 self.defn = ''
180 self._fwdecl = ''
181 self._btin = guardstart('QAPI_TYPES_BUILTIN')
182
183 def visit_end(self):
184 self.decl = self._fwdecl + self.decl
185 self._fwdecl = None
186 # To avoid header dependency hell, we always generate
187 # declarations for built-in types in our header files and
188 # simply guard them. See also do_builtins (command line
189 # option -b).
190 self._btin += guardend('QAPI_TYPES_BUILTIN')
191 self.decl = self._btin + self.decl
192 self._btin = None
193
194 def _gen_type_cleanup(self, name):
195 self.decl += gen_type_cleanup_decl(name)
196 self.defn += gen_type_cleanup(name)
197
198 def visit_enum_type(self, name, info, values, prefix):
199 # Special case for our lone builtin enum type
200 # TODO use something cleaner than existence of info
201 if not info:
202 self._btin += gen_enum(name, values, prefix)
203 if do_builtins:
204 self.defn += gen_enum_lookup(name, values, prefix)
205 else:
206 self._fwdecl += gen_enum(name, values, prefix)
207 self.defn += gen_enum_lookup(name, values, prefix)
208
209 def visit_array_type(self, name, info, element_type):
210 if isinstance(element_type, QAPISchemaBuiltinType):
211 self._btin += gen_fwd_object_or_array(name)
212 self._btin += gen_array(name, element_type)
213 self._btin += gen_type_cleanup_decl(name)
214 if do_builtins:
215 self.defn += gen_type_cleanup(name)
216 else:
217 self._fwdecl += gen_fwd_object_or_array(name)
218 self.decl += gen_array(name, element_type)
219 self._gen_type_cleanup(name)
220
221 def visit_object_type(self, name, info, base, members, variants):
222 # Nothing to do for the special empty builtin
223 if name == 'q_empty':
224 return
225 self._fwdecl += gen_fwd_object_or_array(name)
226 self.decl += gen_object(name, base, members, variants)
227 if base and not base.is_implicit():
228 self.decl += gen_upcast(name, base)
229 # TODO Worth changing the visitor signature, so we could
230 # directly use rather than repeat type.is_implicit()?
231 if not name.startswith('q_'):
232 # implicit types won't be directly allocated/freed
233 self._gen_type_cleanup(name)
234
235 def visit_alternate_type(self, name, info, variants):
236 self._fwdecl += gen_fwd_object_or_array(name)
237 self.decl += gen_object(name, None, [variants.tag_member], variants)
238 self._gen_type_cleanup(name)
239
240 # If you link code generated from multiple schemata, you want only one
241 # instance of the code for built-in types. Generate it only when
242 # do_builtins, enabled by command line option -b. See also
243 # QAPISchemaGenTypeVisitor.visit_end().
244 do_builtins = False
245
246 (input_file, output_dir, do_c, do_h, prefix, opts) = \
247 parse_command_line("b", ["builtins"])
248
249 for o, a in opts:
250 if o in ("-b", "--builtins"):
251 do_builtins = True
252
253 c_comment = '''
254 /*
255 * deallocation functions for schema-defined QAPI types
256 *
257 * Copyright IBM, Corp. 2011
258 *
259 * Authors:
260 * Anthony Liguori <aliguori@us.ibm.com>
261 * Michael Roth <mdroth@linux.vnet.ibm.com>
262 *
263 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
264 * See the COPYING.LIB file in the top-level directory.
265 *
266 */
267 '''
268 h_comment = '''
269 /*
270 * schema-defined QAPI types
271 *
272 * Copyright IBM, Corp. 2011
273 *
274 * Authors:
275 * Anthony Liguori <aliguori@us.ibm.com>
276 *
277 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
278 * See the COPYING.LIB file in the top-level directory.
279 *
280 */
281 '''
282
283 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
284 'qapi-types.c', 'qapi-types.h',
285 c_comment, h_comment)
286
287 fdef.write(mcgen('''
288 #include "qemu/osdep.h"
289 #include "qapi/dealloc-visitor.h"
290 #include "%(prefix)sqapi-types.h"
291 #include "%(prefix)sqapi-visit.h"
292 ''',
293 prefix=prefix))
294
295 schema = QAPISchema(input_file)
296 gen = QAPISchemaGenTypeVisitor()
297 schema.visit(gen)
298 fdef.write(gen.defn)
299 fdecl.write(gen.decl)
300
301 close_output(fdef, fdecl)