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