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