[thirdparty/qemu.git] / scripts / qapi / commands.py

"""
QAPI command marshaller generator

Copyright IBM, Corp. 2011
Copyright (C) 2014-2018 Red Hat, Inc.

Authors:
 Anthony Liguori <aliguori@us.ibm.com>
 Michael Roth <mdroth@linux.vnet.ibm.com>
 Markus Armbruster <armbru@redhat.com>

This work is licensed under the terms of the GNU GPL, version 2.
See the COPYING file in the top-level directory.
"""

from typing import (
    Dict,
    List,
    Optional,
    Set,
)

from .common import c_name, mcgen
from .gen import (
    QAPIGenC,
    QAPISchemaModularCVisitor,
    build_params,
    gen_features,
    ifcontext,
)
from .schema import (
    QAPISchema,
    QAPISchemaFeature,
    QAPISchemaIfCond,
    QAPISchemaObjectType,
    QAPISchemaType,
)
from .source import QAPISourceInfo


def gen_command_decl(name: str,
                     arg_type: Optional[QAPISchemaObjectType],
                     boxed: bool,
                     ret_type: Optional[QAPISchemaType],
                     coroutine: bool) -> str:
    return mcgen('''
%(c_type)s %(coroutine_fn)sqmp_%(c_name)s(%(params)s);
''',
                 c_type=(ret_type and ret_type.c_type()) or 'void',
                 coroutine_fn='coroutine_fn ' if coroutine else '',
                 c_name=c_name(name),
                 params=build_params(arg_type, boxed, 'Error **errp'))


def gen_call(name: str,
             arg_type: Optional[QAPISchemaObjectType],
             boxed: bool,
             ret_type: Optional[QAPISchemaType],
             gen_tracing: bool) -> str:
    ret = ''

    argstr = ''
    if boxed:
        assert arg_type
        argstr = '&arg, '
    elif arg_type:
        assert not arg_type.branches
        for memb in arg_type.members:
            assert not memb.ifcond.is_present()
            if memb.need_has():
                argstr += 'arg.has_%s, ' % c_name(memb.name)
            argstr += 'arg.%s, ' % c_name(memb.name)

    lhs = ''
    if ret_type:
        lhs = 'retval = '

    name = c_name(name)
    upper = name.upper()

    if gen_tracing:
        ret += mcgen('''

    if (trace_event_get_state_backends(TRACE_QMP_ENTER_%(upper)s)) {
        g_autoptr(GString) req_json = qobject_to_json(QOBJECT(args));

        trace_qmp_enter_%(name)s(req_json->str);
    }
''',
                     upper=upper, name=name)

    ret += mcgen('''

    %(lhs)sqmp_%(name)s(%(args)s&err);
''',
                 name=name, args=argstr, lhs=lhs)

    ret += mcgen('''
    if (err) {
''')

    if gen_tracing:
        ret += mcgen('''
        trace_qmp_exit_%(name)s(error_get_pretty(err), false);
''',
                     name=name)

    ret += mcgen('''
        error_propagate(errp, err);
        goto out;
    }
''')

    if ret_type:
        ret += mcgen('''

    qmp_marshal_output_%(c_name)s(retval, ret, errp);
''',
                     c_name=ret_type.c_name())

    if gen_tracing:
        if ret_type:
            ret += mcgen('''

    if (trace_event_get_state_backends(TRACE_QMP_EXIT_%(upper)s)) {
        g_autoptr(GString) ret_json = qobject_to_json(*ret);

        trace_qmp_exit_%(name)s(ret_json->str, true);
    }
''',
                         upper=upper, name=name)
        else:
            ret += mcgen('''

    trace_qmp_exit_%(name)s("{}", true);
''',
                         name=name)

    return ret


def gen_marshal_output(ret_type: QAPISchemaType) -> str:
    return mcgen('''

static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in,
                                QObject **ret_out, Error **errp)
{
    Visitor *v;

    v = qobject_output_visitor_new_qmp(ret_out);
    if (visit_type_%(c_name)s(v, "unused", &ret_in, errp)) {
        visit_complete(v, ret_out);
    }
    visit_free(v);
    v = qapi_dealloc_visitor_new();
    visit_type_%(c_name)s(v, "unused", &ret_in, NULL);
    visit_free(v);
}
''',
                 c_type=ret_type.c_type(), c_name=ret_type.c_name())


def build_marshal_proto(name: str,
                        coroutine: bool) -> str:
    return ('void %(coroutine_fn)sqmp_marshal_%(c_name)s(%(params)s)' % {
        'coroutine_fn': 'coroutine_fn ' if coroutine else '',
        'c_name': c_name(name),
        'params': 'QDict *args, QObject **ret, Error **errp',
    })


def gen_marshal_decl(name: str,
                     coroutine: bool) -> str:
    return mcgen('''
%(proto)s;
''',
                 proto=build_marshal_proto(name, coroutine))


def gen_trace(name: str) -> str:
    return mcgen('''
qmp_enter_%(name)s(const char *json) "%%s"
qmp_exit_%(name)s(const char *result, bool succeeded) "%%s %%d"
''',
                 name=c_name(name))


def gen_marshal(name: str,
                arg_type: Optional[QAPISchemaObjectType],
                boxed: bool,
                ret_type: Optional[QAPISchemaType],
                gen_tracing: bool,
                coroutine: bool) -> str:
    have_args = boxed or (arg_type and not arg_type.is_empty())
    if have_args:
        assert arg_type is not None
        arg_type_c_name = arg_type.c_name()

    ret = mcgen('''

%(proto)s
{
    Error *err = NULL;
    bool ok = false;
    Visitor *v;
''',
                proto=build_marshal_proto(name, coroutine))

    if ret_type:
        ret += mcgen('''
    %(c_type)s retval;
''',
                     c_type=ret_type.c_type())

    if have_args:
        ret += mcgen('''
    %(c_name)s arg = {0};
''',
                     c_name=arg_type_c_name)

    ret += mcgen('''

    v = qobject_input_visitor_new_qmp(QOBJECT(args));
    if (!visit_start_struct(v, NULL, NULL, 0, errp)) {
        goto out;
    }
''')

    if have_args:
        ret += mcgen('''
    if (visit_type_%(c_arg_type)s_members(v, &arg, errp)) {
        ok = visit_check_struct(v, errp);
    }
''',
                     c_arg_type=arg_type_c_name)
    else:
        ret += mcgen('''
    ok = visit_check_struct(v, errp);
''')

    ret += mcgen('''
    visit_end_struct(v, NULL);
    if (!ok) {
        goto out;
    }
''')

    ret += gen_call(name, arg_type, boxed, ret_type, gen_tracing)

    ret += mcgen('''

out:
    visit_free(v);
''')

    ret += mcgen('''
    v = qapi_dealloc_visitor_new();
    visit_start_struct(v, NULL, NULL, 0, NULL);
''')

    if have_args:
        ret += mcgen('''
    visit_type_%(c_arg_type)s_members(v, &arg, NULL);
''',
                     c_arg_type=arg_type_c_name)

    ret += mcgen('''
    visit_end_struct(v, NULL);
    visit_free(v);
''')

    ret += mcgen('''
}
''')
    return ret


def gen_register_command(name: str,
                         features: List[QAPISchemaFeature],
                         success_response: bool,
                         allow_oob: bool,
                         allow_preconfig: bool,
                         coroutine: bool) -> str:
    options = []

    if not success_response:
        options += ['QCO_NO_SUCCESS_RESP']
    if allow_oob:
        options += ['QCO_ALLOW_OOB']
    if allow_preconfig:
        options += ['QCO_ALLOW_PRECONFIG']
    if coroutine:
        options += ['QCO_COROUTINE']

    ret = mcgen('''
    qmp_register_command(cmds, "%(name)s",
                         qmp_marshal_%(c_name)s, %(opts)s, %(feats)s);
''',
                name=name, c_name=c_name(name),
                opts=' | '.join(options) or 0,
                feats=gen_features(features))
    return ret


class QAPISchemaGenCommandVisitor(QAPISchemaModularCVisitor):
    def __init__(self, prefix: str, gen_tracing: bool):
        super().__init__(
            prefix, 'qapi-commands',
            ' * Schema-defined QAPI/QMP commands', None, __doc__,
            gen_tracing=gen_tracing)
        self._visited_ret_types: Dict[QAPIGenC, Set[QAPISchemaType]] = {}
        self._gen_tracing = gen_tracing

    def _begin_user_module(self, name: str) -> None:
        self._visited_ret_types[self._genc] = set()
        commands = self._module_basename('qapi-commands', name)
        types = self._module_basename('qapi-types', name)
        visit = self._module_basename('qapi-visit', name)
        self._genc.add(mcgen('''
#include "qemu/osdep.h"
#include "qapi/compat-policy.h"
#include "qapi/visitor.h"
#include "qobject/qdict.h"
#include "qapi/dealloc-visitor.h"
#include "qapi/error.h"
#include "%(visit)s.h"
#include "%(commands)s.h"
''',
                             commands=commands, visit=visit))

        if self._gen_tracing and commands != 'qapi-commands':
            self._genc.add(mcgen('''
#include "qobject/qjson.h"
#include "trace/trace-%(nm)s_trace_events.h"
''',
                                 nm=c_name(commands, protect=False)))
            # We use c_name(commands, protect=False) to turn '-' into '_', to
            # match .underscorify() in trace/meson.build

        self._genh.add(mcgen('''
#include "%(types)s.h"

''',
                             types=types))

    def visit_begin(self, schema: QAPISchema) -> None:
        self._add_module('./init', ' * QAPI Commands initialization')
        self._genh.add(mcgen('''
#include "qapi/qmp-registry.h"

void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds);
''',
                             c_prefix=c_name(self._prefix, protect=False)))
        self._genc.add(mcgen('''
#include "qemu/osdep.h"
#include "%(prefix)sqapi-commands.h"
#include "%(prefix)sqapi-init-commands.h"
#include "%(prefix)sqapi-features.h"

void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds)
{
    QTAILQ_INIT(cmds);

''',
                             prefix=self._prefix,
                             c_prefix=c_name(self._prefix, protect=False)))

    def visit_end(self) -> None:
        with self._temp_module('./init'):
            self._genc.add(mcgen('''
}
'''))

    def visit_command(self,
                      name: str,
                      info: Optional[QAPISourceInfo],
                      ifcond: QAPISchemaIfCond,
                      features: List[QAPISchemaFeature],
                      arg_type: Optional[QAPISchemaObjectType],
                      ret_type: Optional[QAPISchemaType],
                      gen: bool,
                      success_response: bool,
                      boxed: bool,
                      allow_oob: bool,
                      allow_preconfig: bool,
                      coroutine: bool) -> None:
        if not gen:
            return
        # FIXME: If T is a user-defined type, the user is responsible
        # for making this work, i.e. to make T's condition the
        # conjunction of the T-returning commands' conditions.  If T
        # is a built-in type, this isn't possible: the
        # qmp_marshal_output_T() will be generated unconditionally.
        if ret_type and ret_type not in self._visited_ret_types[self._genc]:
            self._visited_ret_types[self._genc].add(ret_type)
            with ifcontext(ret_type.ifcond,
                           self._genh, self._genc):
                self._genc.add(gen_marshal_output(ret_type))
        with ifcontext(ifcond, self._genh, self._genc):
            self._genh.add(gen_command_decl(name, arg_type, boxed,
                                            ret_type, coroutine))
            self._genh.add(gen_marshal_decl(name, coroutine))
            self._genc.add(gen_marshal(name, arg_type, boxed, ret_type,
                                       self._gen_tracing, coroutine))
            if self._gen_tracing:
                self._gen_trace_events.add(gen_trace(name))
        with self._temp_module('./init'):
            with ifcontext(ifcond, self._genh, self._genc):
                self._genc.add(gen_register_command(
                    name, features, success_response, allow_oob,
                    allow_preconfig, coroutine))


def gen_commands(schema: QAPISchema,
                 output_dir: str,
                 prefix: str,
                 gen_tracing: bool) -> None:
    vis = QAPISchemaGenCommandVisitor(prefix, gen_tracing)
    schema.visit(vis)
    vis.write(output_dir)
Commit	Line	Data
	1	"""
	2	QAPI command marshaller generator
	3
	4	Copyright IBM, Corp. 2011
	5	Copyright (C) 2014-2018 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
	16	from typing import (
	17	Dict,
	18	List,
	19	Optional,
	20	Set,
	21	)
	22
	23	from .common import c_name, mcgen
	24	from .gen import (
	25	QAPIGenC,
	26	QAPISchemaModularCVisitor,
	27	build_params,
	28	gen_features,
	29	ifcontext,
	30	)
	31	from .schema import (
	32	QAPISchema,
	33	QAPISchemaFeature,
	34	QAPISchemaIfCond,
	35	QAPISchemaObjectType,
	36	QAPISchemaType,
	37	)
	38	from .source import QAPISourceInfo
	39
	40
	41	def gen_command_decl(name: str,
	42	arg_type: Optional[QAPISchemaObjectType],
	43	boxed: bool,
	44	ret_type: Optional[QAPISchemaType],
	45	coroutine: bool) -> str:
	46	return mcgen('''
	47	%(c_type)s %(coroutine_fn)sqmp_%(c_name)s(%(params)s);
	48	''',
	49	c_type=(ret_type and ret_type.c_type()) or 'void',
	50	coroutine_fn='coroutine_fn ' if coroutine else '',
	51	c_name=c_name(name),
	52	params=build_params(arg_type, boxed, 'Error **errp'))
	53
	54
	55	def gen_call(name: str,
	56	arg_type: Optional[QAPISchemaObjectType],
	57	boxed: bool,
	58	ret_type: Optional[QAPISchemaType],
	59	gen_tracing: bool) -> str:
	60	ret = ''
	61
	62	argstr = ''
	63	if boxed:
	64	assert arg_type
	65	argstr = '&arg, '
	66	elif arg_type:
	67	assert not arg_type.branches
	68	for memb in arg_type.members:
	69	assert not memb.ifcond.is_present()
	70	if memb.need_has():
	71	argstr += 'arg.has_%s, ' % c_name(memb.name)
	72	argstr += 'arg.%s, ' % c_name(memb.name)
	73
	74	lhs = ''
	75	if ret_type:
	76	lhs = 'retval = '
	77
	78	name = c_name(name)
	79	upper = name.upper()
	80
	81	if gen_tracing:
	82	ret += mcgen('''
	83
	84	if (trace_event_get_state_backends(TRACE_QMP_ENTER_%(upper)s)) {
	85	g_autoptr(GString) req_json = qobject_to_json(QOBJECT(args));
	86
	87	trace_qmp_enter_%(name)s(req_json->str);
	88	}
	89	''',
	90	upper=upper, name=name)
	91
	92	ret += mcgen('''
	93
	94	%(lhs)sqmp_%(name)s(%(args)s&err);
	95	''',
	96	name=name, args=argstr, lhs=lhs)
	97
	98	ret += mcgen('''
	99	if (err) {
	100	''')
	101
	102	if gen_tracing:
	103	ret += mcgen('''
	104	trace_qmp_exit_%(name)s(error_get_pretty(err), false);
	105	''',
	106	name=name)
	107
	108	ret += mcgen('''
	109	error_propagate(errp, err);
	110	goto out;
	111	}
	112	''')
	113
	114	if ret_type:
	115	ret += mcgen('''
	116
	117	qmp_marshal_output_%(c_name)s(retval, ret, errp);
	118	''',
	119	c_name=ret_type.c_name())
	120
	121	if gen_tracing:
	122	if ret_type:
	123	ret += mcgen('''
	124
	125	if (trace_event_get_state_backends(TRACE_QMP_EXIT_%(upper)s)) {
	126	g_autoptr(GString) ret_json = qobject_to_json(*ret);
	127
	128	trace_qmp_exit_%(name)s(ret_json->str, true);
	129	}
	130	''',
	131	upper=upper, name=name)
	132	else:
	133	ret += mcgen('''
	134
	135	trace_qmp_exit_%(name)s("{}", true);
	136	''',
	137	name=name)
	138
	139	return ret
	140
	141
	142	def gen_marshal_output(ret_type: QAPISchemaType) -> str:
	143	return mcgen('''
	144
	145	static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in,
	146	QObject ret_out, Error errp)
	147	{
	148	Visitor *v;
	149
	150	v = qobject_output_visitor_new_qmp(ret_out);
	151	if (visit_type_%(c_name)s(v, "unused", &ret_in, errp)) {
	152	visit_complete(v, ret_out);
	153	}
	154	visit_free(v);
	155	v = qapi_dealloc_visitor_new();
	156	visit_type_%(c_name)s(v, "unused", &ret_in, NULL);
	157	visit_free(v);
	158	}
	159	''',
	160	c_type=ret_type.c_type(), c_name=ret_type.c_name())
	161
	162
	163	def build_marshal_proto(name: str,
	164	coroutine: bool) -> str:
	165	return ('void %(coroutine_fn)sqmp_marshal_%(c_name)s(%(params)s)' % {
	166	'coroutine_fn': 'coroutine_fn ' if coroutine else '',
	167	'c_name': c_name(name),
	168	'params': 'QDict args, QObject ret, Error *errp',
	169	})
	170
	171
	172	def gen_marshal_decl(name: str,
	173	coroutine: bool) -> str:
	174	return mcgen('''
	175	%(proto)s;
	176	''',
	177	proto=build_marshal_proto(name, coroutine))
	178
	179
	180	def gen_trace(name: str) -> str:
	181	return mcgen('''
	182	qmp_enter_%(name)s(const char *json) "%%s"
	183	qmp_exit_%(name)s(const char *result, bool succeeded) "%%s %%d"
	184	''',
	185	name=c_name(name))
	186
	187
	188	def gen_marshal(name: str,
	189	arg_type: Optional[QAPISchemaObjectType],
	190	boxed: bool,
	191	ret_type: Optional[QAPISchemaType],
	192	gen_tracing: bool,
	193	coroutine: bool) -> str:
	194	have_args = boxed or (arg_type and not arg_type.is_empty())
	195	if have_args:
	196	assert arg_type is not None
	197	arg_type_c_name = arg_type.c_name()
	198
	199	ret = mcgen('''
	200
	201	%(proto)s
	202	{
	203	Error *err = NULL;
	204	bool ok = false;
	205	Visitor *v;
	206	''',
	207	proto=build_marshal_proto(name, coroutine))
	208
	209	if ret_type:
	210	ret += mcgen('''
	211	%(c_type)s retval;
	212	''',
	213	c_type=ret_type.c_type())
	214
	215	if have_args:
	216	ret += mcgen('''
	217	%(c_name)s arg = {0};
	218	''',
	219	c_name=arg_type_c_name)
	220
	221	ret += mcgen('''
	222
	223	v = qobject_input_visitor_new_qmp(QOBJECT(args));
	224	if (!visit_start_struct(v, NULL, NULL, 0, errp)) {
	225	goto out;
	226	}
	227	''')
	228
	229	if have_args:
	230	ret += mcgen('''
	231	if (visit_type_%(c_arg_type)s_members(v, &arg, errp)) {
	232	ok = visit_check_struct(v, errp);
	233	}
	234	''',
	235	c_arg_type=arg_type_c_name)
	236	else:
	237	ret += mcgen('''
	238	ok = visit_check_struct(v, errp);
	239	''')
	240
	241	ret += mcgen('''
	242	visit_end_struct(v, NULL);
	243	if (!ok) {
	244	goto out;
	245	}
	246	''')
	247
	248	ret += gen_call(name, arg_type, boxed, ret_type, gen_tracing)
	249
	250	ret += mcgen('''
	251
	252	out:
	253	visit_free(v);
	254	''')
	255
	256	ret += mcgen('''
	257	v = qapi_dealloc_visitor_new();
	258	visit_start_struct(v, NULL, NULL, 0, NULL);
	259	''')
	260
	261	if have_args:
	262	ret += mcgen('''
	263	visit_type_%(c_arg_type)s_members(v, &arg, NULL);
	264	''',
	265	c_arg_type=arg_type_c_name)
	266
	267	ret += mcgen('''
	268	visit_end_struct(v, NULL);
	269	visit_free(v);
	270	''')
	271
	272	ret += mcgen('''
	273	}
	274	''')
	275	return ret
	276
	277
	278	def gen_register_command(name: str,
	279	features: List[QAPISchemaFeature],
	280	success_response: bool,
	281	allow_oob: bool,
	282	allow_preconfig: bool,
	283	coroutine: bool) -> str:
	284	options = []
	285
	286	if not success_response:
	287	options += ['QCO_NO_SUCCESS_RESP']
	288	if allow_oob:
	289	options += ['QCO_ALLOW_OOB']
	290	if allow_preconfig:
	291	options += ['QCO_ALLOW_PRECONFIG']
	292	if coroutine:
	293	options += ['QCO_COROUTINE']
	294
	295	ret = mcgen('''
	296	qmp_register_command(cmds, "%(name)s",
	297	qmp_marshal_%(c_name)s, %(opts)s, %(feats)s);
	298	''',
	299	name=name, c_name=c_name(name),
	300	opts=' \| '.join(options) or 0,
	301	feats=gen_features(features))
	302	return ret
	303
	304
	305	class QAPISchemaGenCommandVisitor(QAPISchemaModularCVisitor):
	306	def __init__(self, prefix: str, gen_tracing: bool):
	307	super().__init__(
	308	prefix, 'qapi-commands',
	309	' * Schema-defined QAPI/QMP commands', None, __doc__,
	310	gen_tracing=gen_tracing)
	311	self._visited_ret_types: Dict[QAPIGenC, Set[QAPISchemaType]] = {}
	312	self._gen_tracing = gen_tracing
	313
	314	def _begin_user_module(self, name: str) -> None:
	315	self._visited_ret_types[self._genc] = set()
	316	commands = self._module_basename('qapi-commands', name)
	317	types = self._module_basename('qapi-types', name)
	318	visit = self._module_basename('qapi-visit', name)
	319	self._genc.add(mcgen('''
	320	#include "qemu/osdep.h"
	321	#include "qapi/compat-policy.h"
	322	#include "qapi/visitor.h"
	323	#include "qobject/qdict.h"
	324	#include "qapi/dealloc-visitor.h"
	325	#include "qapi/error.h"
	326	#include "%(visit)s.h"
	327	#include "%(commands)s.h"
	328	''',
	329	commands=commands, visit=visit))
	330
	331	if self._gen_tracing and commands != 'qapi-commands':
	332	self._genc.add(mcgen('''
	333	#include "qobject/qjson.h"
	334	#include "trace/trace-%(nm)s_trace_events.h"
	335	''',
	336	nm=c_name(commands, protect=False)))
	337	# We use c_name(commands, protect=False) to turn '-' into '_', to
	338	# match .underscorify() in trace/meson.build
	339
	340	self._genh.add(mcgen('''
	341	#include "%(types)s.h"
	342
	343	''',
	344	types=types))
	345
	346	def visit_begin(self, schema: QAPISchema) -> None:
	347	self._add_module('./init', ' * QAPI Commands initialization')
	348	self._genh.add(mcgen('''
	349	#include "qapi/qmp-registry.h"
	350
	351	void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds);
	352	''',
	353	c_prefix=c_name(self._prefix, protect=False)))
	354	self._genc.add(mcgen('''
	355	#include "qemu/osdep.h"
	356	#include "%(prefix)sqapi-commands.h"
	357	#include "%(prefix)sqapi-init-commands.h"
	358	#include "%(prefix)sqapi-features.h"
	359
	360	void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds)
	361	{
	362	QTAILQ_INIT(cmds);
	363
	364	''',
	365	prefix=self._prefix,
	366	c_prefix=c_name(self._prefix, protect=False)))
	367
	368	def visit_end(self) -> None:
	369	with self._temp_module('./init'):
	370	self._genc.add(mcgen('''
	371	}
	372	'''))
	373
	374	def visit_command(self,
	375	name: str,
	376	info: Optional[QAPISourceInfo],
	377	ifcond: QAPISchemaIfCond,
	378	features: List[QAPISchemaFeature],
	379	arg_type: Optional[QAPISchemaObjectType],
	380	ret_type: Optional[QAPISchemaType],
	381	gen: bool,
	382	success_response: bool,
	383	boxed: bool,
	384	allow_oob: bool,
	385	allow_preconfig: bool,
	386	coroutine: bool) -> None:
	387	if not gen:
	388	return
	389	# FIXME: If T is a user-defined type, the user is responsible
	390	# for making this work, i.e. to make T's condition the
	391	# conjunction of the T-returning commands' conditions. If T
	392	# is a built-in type, this isn't possible: the
	393	# qmp_marshal_output_T() will be generated unconditionally.
	394	if ret_type and ret_type not in self._visited_ret_types[self._genc]:
	395	self._visited_ret_types[self._genc].add(ret_type)
	396	with ifcontext(ret_type.ifcond,
	397	self._genh, self._genc):
	398	self._genc.add(gen_marshal_output(ret_type))
	399	with ifcontext(ifcond, self._genh, self._genc):
	400	self._genh.add(gen_command_decl(name, arg_type, boxed,
	401	ret_type, coroutine))
	402	self._genh.add(gen_marshal_decl(name, coroutine))
	403	self._genc.add(gen_marshal(name, arg_type, boxed, ret_type,
	404	self._gen_tracing, coroutine))
	405	if self._gen_tracing:
	406	self._gen_trace_events.add(gen_trace(name))
	407	with self._temp_module('./init'):
	408	with ifcontext(ifcond, self._genh, self._genc):
	409	self._genc.add(gen_register_command(
	410	name, features, success_response, allow_oob,
	411	allow_preconfig, coroutine))
	412
	413
	414	def gen_commands(schema: QAPISchema,
	415	output_dir: str,
	416	prefix: str,
	417	gen_tracing: bool) -> None:
	418	vis = QAPISchemaGenCommandVisitor(prefix, gen_tracing)
	419	schema.visit(vis)
	420	vis.write(output_dir)