mirror of
https://github.com/qemu/qemu.git
synced 2024-12-11 20:53:51 +08:00
ce5fcb472d
For the sake of humans reading introspection output, it is nice to have the name of implicit array types be recognizable as arrays of the underlying type. However, while this patch allows humans to skip from a command with return type "[123]" straight to the definition of type "123" without having to first inspect type "[123]", document that this shortcut should not be taken by client apps. This makes the resulting introspection string slightly larger by default (just over 200 bytes), but it's in the noise (less than 0.3% of the overall 70k size of 'query-qmp-capabilities'). Signed-off-by: Eric Blake <eblake@redhat.com> Message-Id: <1446791754-23823-12-git-send-email-eblake@redhat.com> Signed-off-by: Markus Armbruster <armbru@redhat.com>
219 lines
7.0 KiB
Python
219 lines
7.0 KiB
Python
#
|
|
# QAPI introspection generator
|
|
#
|
|
# Copyright (C) 2015 Red Hat, Inc.
|
|
#
|
|
# Authors:
|
|
# 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 qapi import *
|
|
|
|
|
|
# Caveman's json.dumps() replacement (we're stuck at Python 2.4)
|
|
# TODO try to use json.dumps() once we get unstuck
|
|
def to_json(obj, level=0):
|
|
if obj is None:
|
|
ret = 'null'
|
|
elif isinstance(obj, str):
|
|
ret = '"' + obj.replace('"', r'\"') + '"'
|
|
elif isinstance(obj, list):
|
|
elts = [to_json(elt, level + 1)
|
|
for elt in obj]
|
|
ret = '[' + ', '.join(elts) + ']'
|
|
elif isinstance(obj, dict):
|
|
elts = ['"%s": %s' % (key.replace('"', r'\"'),
|
|
to_json(obj[key], level + 1))
|
|
for key in sorted(obj.keys())]
|
|
ret = '{' + ', '.join(elts) + '}'
|
|
else:
|
|
assert False # not implemented
|
|
if level == 1:
|
|
ret = '\n' + ret
|
|
return ret
|
|
|
|
|
|
def to_c_string(string):
|
|
return '"' + string.replace('\\', r'\\').replace('"', r'\"') + '"'
|
|
|
|
|
|
class QAPISchemaGenIntrospectVisitor(QAPISchemaVisitor):
|
|
def __init__(self, unmask):
|
|
self._unmask = unmask
|
|
self.defn = None
|
|
self.decl = None
|
|
self._schema = None
|
|
self._jsons = None
|
|
self._used_types = None
|
|
self._name_map = None
|
|
|
|
def visit_begin(self, schema):
|
|
self._schema = schema
|
|
self._jsons = []
|
|
self._used_types = []
|
|
self._name_map = {}
|
|
|
|
def visit_end(self):
|
|
# visit the types that are actually used
|
|
jsons = self._jsons
|
|
self._jsons = []
|
|
for typ in self._used_types:
|
|
typ.visit(self)
|
|
# generate C
|
|
# TODO can generate awfully long lines
|
|
jsons.extend(self._jsons)
|
|
name = prefix + 'qmp_schema_json'
|
|
self.decl = mcgen('''
|
|
extern const char %(c_name)s[];
|
|
''',
|
|
c_name=c_name(name))
|
|
lines = to_json(jsons).split('\n')
|
|
c_string = '\n '.join([to_c_string(line) for line in lines])
|
|
self.defn = mcgen('''
|
|
const char %(c_name)s[] = %(c_string)s;
|
|
''',
|
|
c_name=c_name(name),
|
|
c_string=c_string)
|
|
self._schema = None
|
|
self._jsons = None
|
|
self._used_types = None
|
|
self._name_map = None
|
|
|
|
def visit_needed(self, entity):
|
|
# Ignore types on first pass; visit_end() will pick up used types
|
|
return not isinstance(entity, QAPISchemaType)
|
|
|
|
def _name(self, name):
|
|
if self._unmask:
|
|
return name
|
|
if name not in self._name_map:
|
|
self._name_map[name] = '%d' % len(self._name_map)
|
|
return self._name_map[name]
|
|
|
|
def _use_type(self, typ):
|
|
# Map the various integer types to plain int
|
|
if typ.json_type() == 'int':
|
|
typ = self._schema.lookup_type('int')
|
|
elif (isinstance(typ, QAPISchemaArrayType) and
|
|
typ.element_type.json_type() == 'int'):
|
|
typ = self._schema.lookup_type('intList')
|
|
# Add type to work queue if new
|
|
if typ not in self._used_types:
|
|
self._used_types.append(typ)
|
|
# Clients should examine commands and events, not types. Hide
|
|
# type names to reduce the temptation. Also saves a few
|
|
# characters.
|
|
if isinstance(typ, QAPISchemaBuiltinType):
|
|
return typ.name
|
|
if isinstance(typ, QAPISchemaArrayType):
|
|
return '[' + self._use_type(typ.element_type) + ']'
|
|
return self._name(typ.name)
|
|
|
|
def _gen_json(self, name, mtype, obj):
|
|
if mtype not in ('command', 'event', 'builtin', 'array'):
|
|
name = self._name(name)
|
|
obj['name'] = name
|
|
obj['meta-type'] = mtype
|
|
self._jsons.append(obj)
|
|
|
|
def _gen_member(self, member):
|
|
ret = {'name': member.name, 'type': self._use_type(member.type)}
|
|
if member.optional:
|
|
ret['default'] = None
|
|
return ret
|
|
|
|
def _gen_variants(self, tag_name, variants):
|
|
return {'tag': tag_name,
|
|
'variants': [self._gen_variant(v) for v in variants]}
|
|
|
|
def _gen_variant(self, variant):
|
|
return {'case': variant.name, 'type': self._use_type(variant.type)}
|
|
|
|
def visit_builtin_type(self, name, info, json_type):
|
|
self._gen_json(name, 'builtin', {'json-type': json_type})
|
|
|
|
def visit_enum_type(self, name, info, values, prefix):
|
|
self._gen_json(name, 'enum', {'values': values})
|
|
|
|
def visit_array_type(self, name, info, element_type):
|
|
element = self._use_type(element_type)
|
|
self._gen_json('[' + element + ']', 'array', {'element-type': element})
|
|
|
|
def visit_object_type_flat(self, name, info, members, variants):
|
|
obj = {'members': [self._gen_member(m) for m in members]}
|
|
if variants:
|
|
obj.update(self._gen_variants(variants.tag_member.name,
|
|
variants.variants))
|
|
self._gen_json(name, 'object', obj)
|
|
|
|
def visit_alternate_type(self, name, info, variants):
|
|
self._gen_json(name, 'alternate',
|
|
{'members': [{'type': self._use_type(m.type)}
|
|
for m in variants.variants]})
|
|
|
|
def visit_command(self, name, info, arg_type, ret_type,
|
|
gen, success_response):
|
|
arg_type = arg_type or self._schema.the_empty_object_type
|
|
ret_type = ret_type or self._schema.the_empty_object_type
|
|
self._gen_json(name, 'command',
|
|
{'arg-type': self._use_type(arg_type),
|
|
'ret-type': self._use_type(ret_type)})
|
|
|
|
def visit_event(self, name, info, arg_type):
|
|
arg_type = arg_type or self._schema.the_empty_object_type
|
|
self._gen_json(name, 'event', {'arg-type': self._use_type(arg_type)})
|
|
|
|
# Debugging aid: unmask QAPI schema's type names
|
|
# We normally mask them, because they're not QMP wire ABI
|
|
opt_unmask = False
|
|
|
|
(input_file, output_dir, do_c, do_h, prefix, opts) = \
|
|
parse_command_line("u", ["unmask-non-abi-names"])
|
|
|
|
for o, a in opts:
|
|
if o in ("-u", "--unmask-non-abi-names"):
|
|
opt_unmask = True
|
|
|
|
c_comment = '''
|
|
/*
|
|
* QAPI/QMP schema introspection
|
|
*
|
|
* Copyright (C) 2015 Red Hat, Inc.
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*
|
|
*/
|
|
'''
|
|
h_comment = '''
|
|
/*
|
|
* QAPI/QMP schema introspection
|
|
*
|
|
* Copyright (C) 2015 Red Hat, Inc.
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*
|
|
*/
|
|
'''
|
|
|
|
(fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
|
|
'qmp-introspect.c', 'qmp-introspect.h',
|
|
c_comment, h_comment)
|
|
|
|
fdef.write(mcgen('''
|
|
#include "%(prefix)sqmp-introspect.h"
|
|
|
|
''',
|
|
prefix=prefix))
|
|
|
|
schema = QAPISchema(input_file)
|
|
gen = QAPISchemaGenIntrospectVisitor(opt_unmask)
|
|
schema.visit(gen)
|
|
fdef.write(gen.defn)
|
|
fdecl.write(gen.decl)
|
|
|
|
close_output(fdef, fdecl)
|