scripts/qapi-introspect.py

   1 #
   2 # QAPI introspection generator
   3 #
   4 # Copyright (C) 2015 Red Hat, Inc.
   5 #
   6 # Authors:
   7 #  Markus Armbruster <armbru@redhat.com>
   8 #
   9 # This work is licensed under the terms of the GNU GPL, version 2.
  10 # See the COPYING file in the top-level directory.
  11
  12 from qapi import *
  13
  14
  15 # Caveman's json.dumps() replacement (we're stuck at Python 2.4)
  16 # TODO try to use json.dumps() once we get unstuck
  17 def to_json(obj, level=0):
  18     if obj is None:
  19         ret = 'null'
  20     elif isinstance(obj, str):
  21         ret = '"' + obj.replace('"', r'\"') + '"'
  22     elif isinstance(obj, list):
  23         elts = [to_json(elt, level + 1)
  24                 for elt in obj]
  25         ret = '[' + ', '.join(elts) + ']'
  26     elif isinstance(obj, dict):
  27         elts = ['"%s": %s' % (key.replace('"', r'\"'),
  28                               to_json(obj[key], level + 1))
  29                 for key in sorted(obj.keys())]
  30         ret = '{' + ', '.join(elts) + '}'
  31     else:
  32         assert False                # not implemented
  33     if level == 1:
  34         ret = '\n' + ret
  35     return ret
  36
  37
  38 def to_c_string(string):
  39     return '"' + string.replace('\\', r'\\').replace('"', r'\"') + '"'
  40
  41
  42 class QAPISchemaGenIntrospectVisitor(QAPISchemaVisitor):
  43     def __init__(self, unmask):
  44         self._unmask = unmask
  45         self.defn = None
  46         self.decl = None
  47         self._schema = None
  48         self._jsons = None
  49         self._used_types = None
  50         self._name_map = None
  51
  52     def visit_begin(self, schema):
  53         self._schema = schema
  54         self._jsons = []
  55         self._used_types = []
  56         self._name_map = {}
  57
  58     def visit_end(self):
  59         # visit the types that are actually used
  60         jsons = self._jsons
  61         self._jsons = []
  62         for typ in self._used_types:
  63             typ.visit(self)
  64         # generate C
  65         # TODO can generate awfully long lines
  66         jsons.extend(self._jsons)
  67         name = prefix + 'qmp_schema_json'
  68         self.decl = mcgen('''
  69 extern const char %(c_name)s[];
  70 ''',
  71                           c_name=c_name(name))
  72         lines = to_json(jsons).split('\n')
  73         c_string = '\n    '.join([to_c_string(line) for line in lines])
  74         self.defn = mcgen('''
  75 const char %(c_name)s[] = %(c_string)s;
  76 ''',
  77                           c_name=c_name(name),
  78                           c_string=c_string)
  79         self._schema = None
  80         self._jsons = None
  81         self._used_types = None
  82         self._name_map = None
  83
  84     def visit_needed(self, entity):
  85         # Ignore types on first pass; visit_end() will pick up used types
  86         return not isinstance(entity, QAPISchemaType)
  87
  88     def _name(self, name):
  89         if self._unmask:
  90             return name
  91         if name not in self._name_map:
  92             self._name_map[name] = '%d' % len(self._name_map)
  93         return self._name_map[name]
  94
  95     def _use_type(self, typ):
  96         # Map the various integer types to plain int
  97         if typ.json_type() == 'int':
  98             typ = self._schema.lookup_type('int')
  99         elif (isinstance(typ, QAPISchemaArrayType) and
 100               typ.element_type.json_type() == 'int'):
 101             typ = self._schema.lookup_type('intList')
 102         # Add type to work queue if new
 103         if typ not in self._used_types:
 104             self._used_types.append(typ)
 105         # Clients should examine commands and events, not types.  Hide
 106         # type names to reduce the temptation.  Also saves a few
 107         # characters.
 108         if isinstance(typ, QAPISchemaBuiltinType):
 109             return typ.name
 110         return self._name(typ.name)
 111
 112     def _gen_json(self, name, mtype, obj):
 113         if mtype != 'command' and mtype != 'event' and mtype != 'builtin':
 114             name = self._name(name)
 115         obj['name'] = name
 116         obj['meta-type'] = mtype
 117         self._jsons.append(obj)
 118
 119     def _gen_member(self, member):
 120         ret = {'name': member.name, 'type': self._use_type(member.type)}
 121         if member.optional:
 122             ret['default'] = None
 123         return ret
 124
 125     def _gen_variants(self, tag_name, variants):
 126         return {'tag': tag_name,
 127                 'variants': [self._gen_variant(v) for v in variants]}
 128
 129     def _gen_variant(self, variant):
 130         return {'case': variant.name, 'type': self._use_type(variant.type)}
 131
 132     def visit_builtin_type(self, name, info, json_type):
 133         self._gen_json(name, 'builtin', {'json-type': json_type})
 134
 135     def visit_enum_type(self, name, info, values, prefix):
 136         self._gen_json(name, 'enum', {'values': values})
 137
 138     def visit_array_type(self, name, info, element_type):
 139         self._gen_json(name, 'array',
 140                        {'element-type': self._use_type(element_type)})
 141
 142     def visit_object_type_flat(self, name, info, members, variants):
 143         obj = {'members': [self._gen_member(m) for m in members]}
 144         if variants:
 145             obj.update(self._gen_variants(variants.tag_member.name,
 146                                           variants.variants))
 147         self._gen_json(name, 'object', obj)
 148
 149     def visit_alternate_type(self, name, info, variants):
 150         self._gen_json(name, 'alternate',
 151                        {'members': [{'type': self._use_type(m.type)}
 152                                     for m in variants.variants]})
 153
 154     def visit_command(self, name, info, arg_type, ret_type,
 155                       gen, success_response):
 156         arg_type = arg_type or self._schema.the_empty_object_type
 157         ret_type = ret_type or self._schema.the_empty_object_type
 158         self._gen_json(name, 'command',
 159                        {'arg-type': self._use_type(arg_type),
 160                         'ret-type': self._use_type(ret_type)})
 161
 162     def visit_event(self, name, info, arg_type):
 163         arg_type = arg_type or self._schema.the_empty_object_type
 164         self._gen_json(name, 'event', {'arg-type': self._use_type(arg_type)})
 165
 166 # Debugging aid: unmask QAPI schema's type names
 167 # We normally mask them, because they're not QMP wire ABI
 168 opt_unmask = False
 169
 170 (input_file, output_dir, do_c, do_h, prefix, opts) = \
 171     parse_command_line("u", ["unmask-non-abi-names"])
 172
 173 for o, a in opts:
 174     if o in ("-u", "--unmask-non-abi-names"):
 175         opt_unmask = True
 176
 177 c_comment = '''
 178 /*
 179  * QAPI/QMP schema introspection
 180  *
 181  * Copyright (C) 2015 Red Hat, Inc.
 182  *
 183  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 184  * See the COPYING.LIB file in the top-level directory.
 185  *
 186  */
 187 '''
 188 h_comment = '''
 189 /*
 190  * QAPI/QMP schema introspection
 191  *
 192  * Copyright (C) 2015 Red Hat, Inc.
 193  *
 194  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 195  * See the COPYING.LIB file in the top-level directory.
 196  *
 197  */
 198 '''
 199
 200 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 201                             'qmp-introspect.c', 'qmp-introspect.h',
 202                             c_comment, h_comment)
 203
 204 fdef.write(mcgen('''
 205 #include "%(prefix)sqmp-introspect.h"
 206
 207 ''',
 208                  prefix=prefix))
 209
 210 schema = QAPISchema(input_file)
 211 gen = QAPISchemaGenIntrospectVisitor(opt_unmask)
 212 schema.visit(gen)
 213 fdef.write(gen.defn)
 214 fdecl.write(gen.decl)
 215
 216 close_output(fdef, fdecl)