''')
return ''
-def gen_sync_call(name, args, ret_type, indent=0):
+def gen_sync_call(name, args, ret_type):
ret = ""
arglist=""
retval=""
if optional:
arglist += "has_%s, " % c_name(argname)
arglist += "%s, " % (c_name(argname))
- push_indent(indent)
+ push_indent()
ret = mcgen('''
%(retval)sqmp_%(name)s(%(args)s&local_err);
%(marshal_output_call)s
''',
marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
- pop_indent(indent)
+ pop_indent()
return ret.rstrip()
return ""
return "qmp_marshal_output_%s(retval, ret, &local_err);" % c_name(name)
-def gen_visitor_input_containers_decl(args, obj):
+def gen_visitor_input_containers_decl(args):
ret = ""
push_indent()
if len(args) > 0:
ret += mcgen('''
-QmpInputVisitor *mi = qmp_input_visitor_new_strict(%(obj)s);
+QmpInputVisitor *mi = qmp_input_visitor_new_strict(QOBJECT(args));
QapiDeallocVisitor *md;
Visitor *v;
-''',
- obj=obj)
+''')
pop_indent()
return ret.rstrip()
pop_indent()
return ret.rstrip()
-def gen_marshal_output(name, args, ret_type, middle_mode):
+def gen_marshal_output(name, ret_type):
if not ret_type:
return ""
return ret
-def gen_marshal_input_decl(name, args, ret_type, middle_mode):
+def gen_marshal_input_decl(name, middle_mode):
ret = 'void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_name(name)
if not middle_mode:
ret = "static " + ret
return ret
def gen_marshal_input(name, args, ret_type, middle_mode):
- hdr = gen_marshal_input_decl(name, args, ret_type, middle_mode)
+ hdr = gen_marshal_input_decl(name, middle_mode)
ret = mcgen('''
%(header)s
%(visitor_input_block)s
''',
- visitor_input_containers_decl=gen_visitor_input_containers_decl(args, "QOBJECT(args)"),
+ visitor_input_containers_decl=gen_visitor_input_containers_decl(args),
visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
visitor_input_block=gen_visitor_input_block(args))
else:
ret += mcgen('''
%(sync_call)s
''',
- sync_call=gen_sync_call(name, args, ret_type, indent=4))
+ sync_call=gen_sync_call(name, args, ret_type))
if re.search('^ *goto out\\;', ret, re.MULTILINE):
ret += mcgen('''
ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
fdecl.write(ret)
if ret_type:
- ret = gen_marshal_output(cmd['command'], arglist, ret_type, middle_mode) + "\n"
+ ret = gen_marshal_output(cmd['command'], ret_type) + "\n"
fdef.write(ret)
if middle_mode:
- fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], arglist, ret_type, middle_mode))
+ fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], middle_mode))
ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
fdef.write(ret)
c_type=type_name(type))
def generate_visit_struct_fields(name, members, base = None):
- substructs = []
ret = ''
if base:
return ret
-def generate_visit_struct_body(name, members):
+def generate_visit_struct_body(name):
ret = mcgen('''
Error *err = NULL;
''',
name=c_name(name))
- ret += generate_visit_struct_body(name, members)
+ ret += generate_visit_struct_body(name)
ret += mcgen('''
}
''')
return ret
-def generate_visit_list(name, members):
+def generate_visit_list(name):
return mcgen('''
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp)
''',
name=type_name(name))
-def generate_visit_enum(name, members):
+def generate_visit_enum(name):
return mcgen('''
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp)
else:
# There will always be a discriminator in the C switch code, by default
# it is an enum type generated silently
- ret = generate_visit_enum(name + 'Kind', members.keys())
+ ret = generate_visit_enum(name + 'Kind')
disc_type = c_name(name) + 'Kind'
if base:
return ret
-def generate_declaration(name, members, builtin_type=False):
+def generate_declaration(name, builtin_type=False):
ret = ""
if not builtin_type:
name = c_name(name)
return ret
-def generate_enum_declaration(name, members):
+def generate_enum_declaration(name):
ret = mcgen('''
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
''',
return ret
-def generate_decl_enum(name, members):
+def generate_decl_enum(name):
return mcgen('''
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp);
# for built-in types in our header files and simply guard them
fdecl.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
for typename in builtin_types.keys():
- fdecl.write(generate_declaration(typename, None, builtin_type=True))
+ fdecl.write(generate_declaration(typename, builtin_type=True))
fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
# ...this doesn't work for cases where we link in multiple objects that
# over these cases
if do_builtins:
for typename in builtin_types.keys():
- fdef.write(generate_visit_list(typename, None))
+ fdef.write(generate_visit_list(typename))
for expr in exprs:
if expr.has_key('struct'):
ret = generate_visit_struct(expr)
- ret += generate_visit_list(expr['struct'], expr['data'])
+ ret += generate_visit_list(expr['struct'])
fdef.write(ret)
- ret = generate_declaration(expr['struct'], expr['data'])
+ ret = generate_declaration(expr['struct'])
fdecl.write(ret)
elif expr.has_key('union'):
ret = generate_visit_union(expr)
- ret += generate_visit_list(expr['union'], expr['data'])
+ ret += generate_visit_list(expr['union'])
fdef.write(ret)
enum_define = discriminator_find_enum_define(expr)
ret = ""
if not enum_define:
- ret = generate_decl_enum('%sKind' % expr['union'],
- expr['data'].keys())
- ret += generate_declaration(expr['union'], expr['data'])
+ ret = generate_decl_enum('%sKind' % expr['union'])
+ ret += generate_declaration(expr['union'])
fdecl.write(ret)
elif expr.has_key('alternate'):
ret = generate_visit_alternate(expr['alternate'], expr['data'])
- ret += generate_visit_list(expr['alternate'], expr['data'])
+ ret += generate_visit_list(expr['alternate'])
fdef.write(ret)
- ret = generate_decl_enum('%sKind' % expr['alternate'],
- expr['data'].keys())
- ret += generate_declaration(expr['alternate'], expr['data'])
+ ret = generate_decl_enum('%sKind' % expr['alternate'])
+ ret += generate_declaration(expr['alternate'])
fdecl.write(ret)
elif expr.has_key('enum'):
- ret = generate_visit_list(expr['enum'], expr['data'])
- ret += generate_visit_enum(expr['enum'], expr['data'])
+ ret = generate_visit_list(expr['enum'])
+ ret += generate_visit_enum(expr['enum'])
fdef.write(ret)
- ret = generate_decl_enum(expr['enum'], expr['data'])
- ret += generate_enum_declaration(expr['enum'], expr['data'])
+ ret = generate_decl_enum(expr['enum'])
+ ret += generate_enum_declaration(expr['enum'])
fdecl.write(ret)
close_output(fdef, fdecl)