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