scripts/qapi-visit.py

   1 #
   2 # QAPI visitor generator
   3 #
   4 # Copyright IBM, Corp. 2011
   5 # Copyright (C) 2014-2016 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 qapi import *
  16 import re
  17
  18
  19 def gen_visit_decl(name, scalar=False):
  20     c_type = c_name(name) + ' *'
  21     if not scalar:
  22         c_type += '*'
  23     return mcgen('''
  24 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_type)sobj, Error **errp);
  25 ''',
  26                  c_name=c_name(name), c_type=c_type)
  27
  28
  29 def gen_visit_members_decl(name):
  30     return mcgen('''
  31
  32 void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp);
  33 ''',
  34                  c_name=c_name(name))
  35
  36
  37 def gen_visit_object_members(name, base, members, variants):
  38     ret = mcgen('''
  39
  40 void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp)
  41 {
  42     Error *err = NULL;
  43
  44 ''',
  45                 c_name=c_name(name))
  46
  47     if base:
  48         ret += mcgen('''
  49     visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, &err);
  50 ''',
  51                      c_type=base.c_name())
  52         ret += gen_err_check()
  53
  54     ret += gen_visit_members(members, prefix='obj->')
  55
  56     if variants:
  57         ret += mcgen('''
  58     switch (obj->%(c_name)s) {
  59 ''',
  60                      c_name=c_name(variants.tag_member.name))
  61
  62         for var in variants.variants:
  63             # TODO ugly special case for simple union
  64             simple_union_type = var.simple_union_type()
  65             ret += mcgen('''
  66     case %(case)s:
  67 ''',
  68                          case=c_enum_const(variants.tag_member.type.name,
  69                                            var.name,
  70                                            variants.tag_member.type.prefix))
  71             if simple_union_type:
  72                 ret += mcgen('''
  73         visit_type_%(c_type)s(v, "data", &obj->u.%(c_name)s, &err);
  74 ''',
  75                              c_type=simple_union_type.c_name(),
  76                              c_name=c_name(var.name))
  77             else:
  78                 ret += mcgen('''
  79         visit_type_%(c_type)s_members(v, &obj->u.%(c_name)s, &err);
  80 ''',
  81                              c_type=var.type.c_name(),
  82                              c_name=c_name(var.name))
  83             ret += mcgen('''
  84         break;
  85 ''')
  86
  87         ret += mcgen('''
  88     default:
  89         abort();
  90     }
  91 ''')
  92
  93     # 'goto out' produced for base, by gen_visit_members() for each member,
  94     # and if variants were present
  95     if base or members or variants:
  96         ret += mcgen('''
  97
  98 out:
  99 ''')
 100     ret += mcgen('''
 101     error_propagate(errp, err);
 102 }
 103 ''')
 104     return ret
 105
 106
 107 def gen_visit_list(name, element_type):
 108     # FIXME: if *obj is NULL on entry, and the first visit_next_list()
 109     # assigns to *obj, while a later one fails, we should clean up *obj
 110     # rather than leaving it non-NULL. As currently written, the caller must
 111     # call qapi_free_FOOList() to avoid a memory leak of the partial FOOList.
 112     return mcgen('''
 113
 114 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
 115 {
 116     Error *err = NULL;
 117     GenericList *i, **prev;
 118
 119     visit_start_list(v, name, &err);
 120     if (err) {
 121         goto out;
 122     }
 123
 124     for (prev = (GenericList **)obj;
 125          !err && (i = visit_next_list(v, prev, sizeof(**obj))) != NULL;
 126          prev = &i) {
 127         %(c_name)s *native_i = (%(c_name)s *)i;
 128         visit_type_%(c_elt_type)s(v, NULL, &native_i->value, &err);
 129     }
 130
 131     visit_end_list(v);
 132 out:
 133     error_propagate(errp, err);
 134 }
 135 ''',
 136                  c_name=c_name(name), c_elt_type=element_type.c_name())
 137
 138
 139 def gen_visit_enum(name):
 140     return mcgen('''
 141
 142 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s *obj, Error **errp)
 143 {
 144     int value = *obj;
 145     visit_type_enum(v, name, &value, %(c_name)s_lookup, errp);
 146     *obj = value;
 147 }
 148 ''',
 149                  c_name=c_name(name))
 150
 151
 152 def gen_visit_alternate(name, variants):
 153     promote_int = 'true'
 154     ret = ''
 155     for var in variants.variants:
 156         if var.type.alternate_qtype() == 'QTYPE_QINT':
 157             promote_int = 'false'
 158
 159     ret += mcgen('''
 160
 161 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
 162 {
 163     Error *err = NULL;
 164
 165     visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
 166                           %(promote_int)s, &err);
 167     if (err) {
 168         goto out;
 169     }
 170     switch ((*obj)->type) {
 171 ''',
 172                  c_name=c_name(name), promote_int=promote_int)
 173
 174     for var in variants.variants:
 175         ret += mcgen('''
 176     case %(case)s:
 177 ''',
 178                      case=var.type.alternate_qtype())
 179         if isinstance(var.type, QAPISchemaObjectType):
 180             ret += mcgen('''
 181         visit_start_struct(v, name, NULL, 0, &err);
 182         if (err) {
 183             break;
 184         }
 185         visit_type_%(c_type)s_members(v, &(*obj)->u.%(c_name)s, &err);
 186         error_propagate(errp, err);
 187         err = NULL;
 188         visit_end_struct(v, &err);
 189 ''',
 190                          c_type=var.type.c_name(),
 191                          c_name=c_name(var.name))
 192         else:
 193             ret += mcgen('''
 194         visit_type_%(c_type)s(v, name, &(*obj)->u.%(c_name)s, &err);
 195 ''',
 196                          c_type=var.type.c_name(),
 197                          c_name=c_name(var.name))
 198         ret += mcgen('''
 199         break;
 200 ''')
 201
 202     ret += mcgen('''
 203     default:
 204         error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 205                    "%(name)s");
 206     }
 207     visit_end_alternate(v);
 208 out:
 209     error_propagate(errp, err);
 210 }
 211 ''',
 212                  name=name)
 213
 214     return ret
 215
 216
 217 def gen_visit_object(name, base, members, variants):
 218     ret = gen_visit_object_members(name, base, members, variants)
 219
 220     # FIXME: if *obj is NULL on entry, and visit_start_struct() assigns to
 221     # *obj, but then visit_type_FOO_members() fails, we should clean up *obj
 222     # rather than leaving it non-NULL. As currently written, the caller must
 223     # call qapi_free_FOO() to avoid a memory leak of the partial FOO.
 224     ret += mcgen('''
 225
 226 void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp)
 227 {
 228     Error *err = NULL;
 229
 230     visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), &err);
 231     if (err) {
 232         goto out;
 233     }
 234     if (!*obj) {
 235         goto out_obj;
 236     }
 237     visit_type_%(c_name)s_members(v, *obj, &err);
 238     error_propagate(errp, err);
 239     err = NULL;
 240 out_obj:
 241     visit_end_struct(v, &err);
 242 out:
 243     error_propagate(errp, err);
 244 }
 245 ''',
 246                  c_name=c_name(name))
 247
 248     return ret
 249
 250
 251 class QAPISchemaGenVisitVisitor(QAPISchemaVisitor):
 252     def __init__(self):
 253         self.decl = None
 254         self.defn = None
 255         self._btin = None
 256
 257     def visit_begin(self, schema):
 258         self.decl = ''
 259         self.defn = ''
 260         self._btin = guardstart('QAPI_VISIT_BUILTIN')
 261
 262     def visit_end(self):
 263         # To avoid header dependency hell, we always generate
 264         # declarations for built-in types in our header files and
 265         # simply guard them.  See also do_builtins (command line
 266         # option -b).
 267         self._btin += guardend('QAPI_VISIT_BUILTIN')
 268         self.decl = self._btin + self.decl
 269         self._btin = None
 270
 271     def visit_needed(self, entity):
 272         # Visit everything except implicit objects
 273         return not (entity.is_implicit() and
 274                     isinstance(entity, QAPISchemaObjectType))
 275
 276     def visit_enum_type(self, name, info, values, prefix):
 277         # Special case for our lone builtin enum type
 278         # TODO use something cleaner than existence of info
 279         if not info:
 280             self._btin += gen_visit_decl(name, scalar=True)
 281             if do_builtins:
 282                 self.defn += gen_visit_enum(name)
 283         else:
 284             self.decl += gen_visit_decl(name, scalar=True)
 285             self.defn += gen_visit_enum(name)
 286
 287     def visit_array_type(self, name, info, element_type):
 288         decl = gen_visit_decl(name)
 289         defn = gen_visit_list(name, element_type)
 290         if isinstance(element_type, QAPISchemaBuiltinType):
 291             self._btin += decl
 292             if do_builtins:
 293                 self.defn += defn
 294         else:
 295             self.decl += decl
 296             self.defn += defn
 297
 298     def visit_object_type(self, name, info, base, members, variants):
 299         self.decl += gen_visit_members_decl(name)
 300         self.decl += gen_visit_decl(name)
 301         self.defn += gen_visit_object(name, base, members, variants)
 302
 303     def visit_alternate_type(self, name, info, variants):
 304         self.decl += gen_visit_decl(name)
 305         self.defn += gen_visit_alternate(name, variants)
 306
 307 # If you link code generated from multiple schemata, you want only one
 308 # instance of the code for built-in types.  Generate it only when
 309 # do_builtins, enabled by command line option -b.  See also
 310 # QAPISchemaGenVisitVisitor.visit_end().
 311 do_builtins = False
 312
 313 (input_file, output_dir, do_c, do_h, prefix, opts) = \
 314     parse_command_line("b", ["builtins"])
 315
 316 for o, a in opts:
 317     if o in ("-b", "--builtins"):
 318         do_builtins = True
 319
 320 c_comment = '''
 321 /*
 322  * schema-defined QAPI visitor functions
 323  *
 324  * Copyright IBM, Corp. 2011
 325  *
 326  * Authors:
 327  *  Anthony Liguori   <aliguori@us.ibm.com>
 328  *
 329  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 330  * See the COPYING.LIB file in the top-level directory.
 331  *
 332  */
 333 '''
 334 h_comment = '''
 335 /*
 336  * schema-defined QAPI visitor functions
 337  *
 338  * Copyright IBM, Corp. 2011
 339  *
 340  * Authors:
 341  *  Anthony Liguori   <aliguori@us.ibm.com>
 342  *
 343  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 344  * See the COPYING.LIB file in the top-level directory.
 345  *
 346  */
 347 '''
 348
 349 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 350                             'qapi-visit.c', 'qapi-visit.h',
 351                             c_comment, h_comment)
 352
 353 fdef.write(mcgen('''
 354 #include "qemu/osdep.h"
 355 #include "qemu-common.h"
 356 #include "%(prefix)sqapi-visit.h"
 357 ''',
 358                  prefix=prefix))
 359
 360 fdecl.write(mcgen('''
 361 #include "qapi/visitor.h"
 362 #include "qapi/qmp/qerror.h"
 363 #include "%(prefix)sqapi-types.h"
 364
 365 ''',
 366                   prefix=prefix))
 367
 368 schema = QAPISchema(input_file)
 369 gen = QAPISchemaGenVisitVisitor()
 370 schema.visit(gen)
 371 fdef.write(gen.defn)
 372 fdecl.write(gen.decl)
 373
 374 close_output(fdef, fdecl)