qdev: split out UI portions into a new function
[qemu.git] / scripts / qapi-commands.py
1 #
2 # QAPI command marshaller generator
3 #
4 # Copyright IBM, Corp. 2011
5 #
6 # Authors:
7 # Anthony Liguori <aliguori@us.ibm.com>
8 # Michael Roth <mdroth@linux.vnet.ibm.com>
9 #
10 # This work is licensed under the terms of the GNU GPLv2.
11 # See the COPYING.LIB file in the top-level directory.
12
13 from ordereddict import OrderedDict
14 from qapi import *
15 import sys
16 import os
17 import getopt
18 import errno
19
20 def type_visitor(name):
21 if type(name) == list:
22 return 'visit_type_%sList' % name[0]
23 else:
24 return 'visit_type_%s' % name
25
26 def generate_decl_enum(name, members, genlist=True):
27 return mcgen('''
28
29 void %(visitor)s(Visitor *m, %(name)s * obj, const char *name, Error **errp);
30 ''',
31 visitor=type_visitor(name))
32
33 def generate_command_decl(name, args, ret_type):
34 arglist=""
35 for argname, argtype, optional, structured in parse_args(args):
36 argtype = c_type(argtype)
37 if argtype == "char *":
38 argtype = "const char *"
39 if optional:
40 arglist += "bool has_%s, " % c_var(argname)
41 arglist += "%s %s, " % (argtype, c_var(argname))
42 return mcgen('''
43 %(ret_type)s qmp_%(name)s(%(args)sError **errp);
44 ''',
45 ret_type=c_type(ret_type), name=c_var(name), args=arglist).strip()
46
47 def gen_sync_call(name, args, ret_type, indent=0):
48 ret = ""
49 arglist=""
50 retval=""
51 if ret_type:
52 retval = "retval = "
53 for argname, argtype, optional, structured in parse_args(args):
54 if optional:
55 arglist += "has_%s, " % c_var(argname)
56 arglist += "%s, " % (c_var(argname))
57 push_indent(indent)
58 ret = mcgen('''
59 %(retval)sqmp_%(name)s(%(args)serrp);
60
61 ''',
62 name=c_var(name), args=arglist, retval=retval).rstrip()
63 if ret_type:
64 ret += "\n" + mcgen(''''
65 if (!error_is_set(errp)) {
66 %(marshal_output_call)s
67 }
68 ''',
69 marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
70 pop_indent(indent)
71 return ret.rstrip()
72
73
74 def gen_marshal_output_call(name, ret_type):
75 if not ret_type:
76 return ""
77 return "qmp_marshal_output_%s(retval, ret, errp);" % c_var(name)
78
79 def gen_visitor_output_containers_decl(ret_type):
80 ret = ""
81 push_indent()
82 if ret_type:
83 ret += mcgen('''
84 QmpOutputVisitor *mo;
85 QapiDeallocVisitor *md;
86 Visitor *v;
87 ''')
88 pop_indent()
89
90 return ret
91
92 def gen_visitor_input_containers_decl(args):
93 ret = ""
94
95 push_indent()
96 if len(args) > 0:
97 ret += mcgen('''
98 QmpInputVisitor *mi;
99 QapiDeallocVisitor *md;
100 Visitor *v;
101 ''')
102 pop_indent()
103
104 return ret.rstrip()
105
106 def gen_visitor_input_vars_decl(args):
107 ret = ""
108 push_indent()
109 for argname, argtype, optional, structured in parse_args(args):
110 if optional:
111 ret += mcgen('''
112 bool has_%(argname)s = false;
113 ''',
114 argname=c_var(argname))
115 if c_type(argtype).endswith("*"):
116 ret += mcgen('''
117 %(argtype)s %(argname)s = NULL;
118 ''',
119 argname=c_var(argname), argtype=c_type(argtype))
120 else:
121 ret += mcgen('''
122 %(argtype)s %(argname)s;
123 ''',
124 argname=c_var(argname), argtype=c_type(argtype))
125
126 pop_indent()
127 return ret.rstrip()
128
129 def gen_visitor_input_block(args, obj, dealloc=False):
130 ret = ""
131 if len(args) == 0:
132 return ret
133
134 push_indent()
135
136 if dealloc:
137 ret += mcgen('''
138 md = qapi_dealloc_visitor_new();
139 v = qapi_dealloc_get_visitor(md);
140 ''')
141 else:
142 ret += mcgen('''
143 mi = qmp_input_visitor_new(%(obj)s);
144 v = qmp_input_get_visitor(mi);
145 ''',
146 obj=obj)
147
148 for argname, argtype, optional, structured in parse_args(args):
149 if optional:
150 ret += mcgen('''
151 visit_start_optional(v, &has_%(c_name)s, "%(name)s", errp);
152 if (has_%(c_name)s) {
153 ''',
154 c_name=c_var(argname), name=argname)
155 push_indent()
156 ret += mcgen('''
157 %(visitor)s(v, &%(c_name)s, "%(name)s", errp);
158 ''',
159 c_name=c_var(argname), name=argname, argtype=argtype,
160 visitor=type_visitor(argtype))
161 if optional:
162 pop_indent()
163 ret += mcgen('''
164 }
165 visit_end_optional(v, errp);
166 ''')
167
168 if dealloc:
169 ret += mcgen('''
170 qapi_dealloc_visitor_cleanup(md);
171 ''')
172 else:
173 ret += mcgen('''
174 qmp_input_visitor_cleanup(mi);
175 ''')
176 pop_indent()
177 return ret.rstrip()
178
179 def gen_marshal_output(name, args, ret_type, middle_mode):
180 if not ret_type:
181 return ""
182
183 ret = mcgen('''
184 static void qmp_marshal_output_%(c_name)s(%(c_ret_type)s ret_in, QObject **ret_out, Error **errp)
185 {
186 QapiDeallocVisitor *md = qapi_dealloc_visitor_new();
187 QmpOutputVisitor *mo = qmp_output_visitor_new();
188 Visitor *v;
189
190 v = qmp_output_get_visitor(mo);
191 %(visitor)s(v, &ret_in, "unused", errp);
192 if (!error_is_set(errp)) {
193 *ret_out = qmp_output_get_qobject(mo);
194 }
195 qmp_output_visitor_cleanup(mo);
196 v = qapi_dealloc_get_visitor(md);
197 %(visitor)s(v, &ret_in, "unused", errp);
198 qapi_dealloc_visitor_cleanup(md);
199 }
200 ''',
201 c_ret_type=c_type(ret_type), c_name=c_var(name),
202 visitor=type_visitor(ret_type))
203
204 return ret
205
206 def gen_marshal_input_decl(name, args, ret_type, middle_mode):
207 if middle_mode:
208 return 'int qmp_marshal_input_%s(Monitor *mon, const QDict *qdict, QObject **ret)' % c_var(name)
209 else:
210 return 'static void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_var(name)
211
212
213
214 def gen_marshal_input(name, args, ret_type, middle_mode):
215 hdr = gen_marshal_input_decl(name, args, ret_type, middle_mode)
216
217 ret = mcgen('''
218 %(header)s
219 {
220 ''',
221 header=hdr)
222
223 if middle_mode:
224 ret += mcgen('''
225 Error *local_err = NULL;
226 Error **errp = &local_err;
227 QDict *args = (QDict *)qdict;
228 ''')
229
230 if ret_type:
231 if c_type(ret_type).endswith("*"):
232 retval = " %s retval = NULL;" % c_type(ret_type)
233 else:
234 retval = " %s retval;" % c_type(ret_type)
235 ret += mcgen('''
236 %(retval)s
237 ''',
238 retval=retval)
239
240 if len(args) > 0:
241 ret += mcgen('''
242 %(visitor_input_containers_decl)s
243 %(visitor_input_vars_decl)s
244
245 %(visitor_input_block)s
246
247 ''',
248 visitor_input_containers_decl=gen_visitor_input_containers_decl(args),
249 visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
250 visitor_input_block=gen_visitor_input_block(args, "QOBJECT(args)"))
251 else:
252 ret += mcgen('''
253 (void)args;
254 ''')
255
256 ret += mcgen('''
257 if (error_is_set(errp)) {
258 goto out;
259 }
260 %(sync_call)s
261 ''',
262 sync_call=gen_sync_call(name, args, ret_type, indent=4))
263 ret += mcgen('''
264
265 out:
266 ''')
267 ret += mcgen('''
268 %(visitor_input_block_cleanup)s
269 ''',
270 visitor_input_block_cleanup=gen_visitor_input_block(args, None,
271 dealloc=True))
272
273 if middle_mode:
274 ret += mcgen('''
275
276 if (local_err) {
277 qerror_report_err(local_err);
278 error_free(local_err);
279 return -1;
280 }
281 return 0;
282 ''')
283 else:
284 ret += mcgen('''
285 return;
286 ''')
287
288 ret += mcgen('''
289 }
290 ''')
291
292 return ret
293
294 def gen_registry(commands):
295 registry=""
296 push_indent()
297 for cmd in commands:
298 registry += mcgen('''
299 qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s);
300 ''',
301 name=cmd['command'], c_name=c_var(cmd['command']))
302 pop_indent()
303 ret = mcgen('''
304 static void qmp_init_marshal(void)
305 {
306 %(registry)s
307 }
308
309 qapi_init(qmp_init_marshal);
310 ''',
311 registry=registry.rstrip())
312 return ret
313
314 def gen_command_decl_prologue(header, guard, prefix=""):
315 ret = mcgen('''
316 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
317
318 /*
319 * schema-defined QAPI function prototypes
320 *
321 * Copyright IBM, Corp. 2011
322 *
323 * Authors:
324 * Anthony Liguori <aliguori@us.ibm.com>
325 *
326 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
327 * See the COPYING.LIB file in the top-level directory.
328 *
329 */
330
331 #ifndef %(guard)s
332 #define %(guard)s
333
334 #include "%(prefix)sqapi-types.h"
335 #include "error.h"
336
337 ''',
338 header=basename(header), guard=guardname(header), prefix=prefix)
339 return ret
340
341 def gen_command_def_prologue(prefix="", proxy=False):
342 ret = mcgen('''
343 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
344
345 /*
346 * schema-defined QMP->QAPI command dispatch
347 *
348 * Copyright IBM, Corp. 2011
349 *
350 * Authors:
351 * Anthony Liguori <aliguori@us.ibm.com>
352 *
353 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
354 * See the COPYING.LIB file in the top-level directory.
355 *
356 */
357
358 #include "qemu-objects.h"
359 #include "qapi/qmp-core.h"
360 #include "qapi/qapi-visit-core.h"
361 #include "qapi/qmp-output-visitor.h"
362 #include "qapi/qmp-input-visitor.h"
363 #include "qapi/qapi-dealloc-visitor.h"
364 #include "%(prefix)sqapi-types.h"
365 #include "%(prefix)sqapi-visit.h"
366
367 ''',
368 prefix=prefix)
369 if not proxy:
370 ret += '#include "%sqmp-commands.h"' % prefix
371 return ret + "\n\n"
372
373
374 try:
375 opts, args = getopt.gnu_getopt(sys.argv[1:], "chp:o:m",
376 ["source", "header", "prefix=",
377 "output-dir=", "type=", "middle"])
378 except getopt.GetoptError, err:
379 print str(err)
380 sys.exit(1)
381
382 output_dir = ""
383 prefix = ""
384 dispatch_type = "sync"
385 c_file = 'qmp-marshal.c'
386 h_file = 'qmp-commands.h'
387 middle_mode = False
388
389 do_c = False
390 do_h = False
391
392 for o, a in opts:
393 if o in ("-p", "--prefix"):
394 prefix = a
395 elif o in ("-o", "--output-dir"):
396 output_dir = a + "/"
397 elif o in ("-t", "--type"):
398 dispatch_type = a
399 elif o in ("-m", "--middle"):
400 middle_mode = True
401 elif o in ("-c", "--source"):
402 do_c = True
403 elif o in ("-h", "--header"):
404 do_h = True
405
406 if not do_c and not do_h:
407 do_c = True
408 do_h = True
409
410 c_file = output_dir + prefix + c_file
411 h_file = output_dir + prefix + h_file
412
413 def maybe_open(really, name, opt):
414 if really:
415 return open(name, opt)
416 else:
417 import StringIO
418 return StringIO.StringIO()
419
420 try:
421 os.makedirs(output_dir)
422 except os.error, e:
423 if e.errno != errno.EEXIST:
424 raise
425
426 exprs = parse_schema(sys.stdin)
427 commands = filter(lambda expr: expr.has_key('command'), exprs)
428 commands = filter(lambda expr: not expr.has_key('gen'), commands)
429
430 if dispatch_type == "sync":
431 fdecl = maybe_open(do_h, h_file, 'w')
432 fdef = maybe_open(do_c, c_file, 'w')
433 ret = gen_command_decl_prologue(header=basename(h_file), guard=guardname(h_file), prefix=prefix)
434 fdecl.write(ret)
435 ret = gen_command_def_prologue(prefix=prefix)
436 fdef.write(ret)
437
438 for cmd in commands:
439 arglist = []
440 ret_type = None
441 if cmd.has_key('data'):
442 arglist = cmd['data']
443 if cmd.has_key('returns'):
444 ret_type = cmd['returns']
445 ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
446 fdecl.write(ret)
447 if ret_type:
448 ret = gen_marshal_output(cmd['command'], arglist, ret_type, middle_mode) + "\n"
449 fdef.write(ret)
450
451 if middle_mode:
452 fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], arglist, ret_type, middle_mode))
453
454 ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
455 fdef.write(ret)
456
457 fdecl.write("\n#endif\n");
458
459 if not middle_mode:
460 ret = gen_registry(commands)
461 fdef.write(ret)
462
463 fdef.flush()
464 fdef.close()
465 fdecl.flush()
466 fdecl.close()