scripts/qapi-visit.py

   1 #
   2 # QAPI visitor generator
   3 #
   4 # Copyright IBM, Corp. 2011
   5 # Copyright (C) 2014-2015 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 implicit_structs_seen = set()
  19 struct_fields_seen = set()
  20
  21
  22 def gen_visit_decl(name, scalar=False):
  23     c_type = c_name(name) + ' *'
  24     if not scalar:
  25         c_type += '*'
  26     return mcgen('''
  27 void visit_type_%(c_name)s(Visitor *m, %(c_type)sobj, const char *name, Error **errp);
  28 ''',
  29                  c_name=c_name(name), c_type=c_type)
  30
  31
  32 def gen_visit_implicit_struct(typ):
  33     if typ in implicit_structs_seen:
  34         return ''
  35     implicit_structs_seen.add(typ)
  36
  37     ret = ''
  38     if typ.name not in struct_fields_seen:
  39         # Need a forward declaration
  40         ret += mcgen('''
  41
  42 static void visit_type_%(c_type)s_fields(Visitor *m, %(c_type)s **obj, Error **errp);
  43 ''',
  44                      c_type=typ.c_name())
  45
  46     ret += mcgen('''
  47
  48 static void visit_type_implicit_%(c_type)s(Visitor *m, %(c_type)s **obj, Error **errp)
  49 {
  50     Error *err = NULL;
  51
  52     visit_start_implicit_struct(m, (void **)obj, sizeof(%(c_type)s), &err);
  53     if (!err) {
  54         visit_type_%(c_type)s_fields(m, obj, errp);
  55         visit_end_implicit_struct(m, &err);
  56     }
  57     error_propagate(errp, err);
  58 }
  59 ''',
  60                  c_type=typ.c_name())
  61     return ret
  62
  63
  64 def gen_visit_struct_fields(name, base, members):
  65     struct_fields_seen.add(name)
  66
  67     ret = ''
  68
  69     if base:
  70         ret += gen_visit_implicit_struct(base)
  71
  72     ret += mcgen('''
  73
  74 static void visit_type_%(c_name)s_fields(Visitor *m, %(c_name)s **obj, Error **errp)
  75 {
  76     Error *err = NULL;
  77
  78 ''',
  79                  c_name=c_name(name))
  80     push_indent()
  81
  82     if base:
  83         ret += mcgen('''
  84 visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);
  85 if (err) {
  86     goto out;
  87 }
  88 ''',
  89                      c_type=base.c_name(), c_name=c_name('base'))
  90
  91     for memb in members:
  92         if memb.optional:
  93             ret += mcgen('''
  94 visit_optional(m, &(*obj)->has_%(c_name)s, "%(name)s", &err);
  95 if (!err && (*obj)->has_%(c_name)s) {
  96 ''',
  97                          c_name=c_name(memb.name), name=memb.name)
  98             push_indent()
  99
 100         ret += mcgen('''
 101 visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "%(name)s", &err);
 102 ''',
 103                      c_type=memb.type.c_name(), c_name=c_name(memb.name),
 104                      name=memb.name)
 105
 106         if memb.optional:
 107             pop_indent()
 108             ret += mcgen('''
 109 }
 110 ''')
 111         ret += mcgen('''
 112 if (err) {
 113     goto out;
 114 }
 115 ''')
 116
 117     pop_indent()
 118     if re.search('^ *goto out;', ret, re.MULTILINE):
 119         ret += mcgen('''
 120
 121 out:
 122 ''')
 123     ret += mcgen('''
 124     error_propagate(errp, err);
 125 }
 126 ''')
 127     return ret
 128
 129
 130 def gen_visit_struct(name, base, members):
 131     ret = gen_visit_struct_fields(name, base, members)
 132
 133     # FIXME: if *obj is NULL on entry, and visit_start_struct() assigns to
 134     # *obj, but then visit_type_FOO_fields() fails, we should clean up *obj
 135     # rather than leaving it non-NULL. As currently written, the caller must
 136     # call qapi_free_FOO() to avoid a memory leak of the partial FOO.
 137     ret += mcgen('''
 138
 139 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
 140 {
 141     Error *err = NULL;
 142
 143     visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
 144     if (!err) {
 145         if (*obj) {
 146             visit_type_%(c_name)s_fields(m, obj, errp);
 147         }
 148         visit_end_struct(m, &err);
 149     }
 150     error_propagate(errp, err);
 151 }
 152 ''',
 153                  name=name, c_name=c_name(name))
 154
 155     return ret
 156
 157
 158 def gen_visit_list(name, element_type):
 159     return mcgen('''
 160
 161 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
 162 {
 163     Error *err = NULL;
 164     GenericList *i, **prev;
 165
 166     visit_start_list(m, name, &err);
 167     if (err) {
 168         goto out;
 169     }
 170
 171     for (prev = (GenericList **)obj;
 172          !err && (i = visit_next_list(m, prev, &err)) != NULL;
 173          prev = &i) {
 174         %(c_name)s *native_i = (%(c_name)s *)i;
 175         visit_type_%(c_elt_type)s(m, &native_i->value, NULL, &err);
 176     }
 177
 178     error_propagate(errp, err);
 179     err = NULL;
 180     visit_end_list(m, &err);
 181 out:
 182     error_propagate(errp, err);
 183 }
 184 ''',
 185                  c_name=c_name(name), c_elt_type=element_type.c_name())
 186
 187
 188 def gen_visit_enum(name):
 189     return mcgen('''
 190
 191 void visit_type_%(c_name)s(Visitor *m, %(c_name)s *obj, const char *name, Error **errp)
 192 {
 193     visit_type_enum(m, (int *)obj, %(c_name)s_lookup, "%(name)s", name, errp);
 194 }
 195 ''',
 196                  c_name=c_name(name), name=name)
 197
 198
 199 def gen_visit_alternate(name, variants):
 200     ret = mcgen('''
 201
 202 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
 203 {
 204     Error *err = NULL;
 205
 206     visit_start_implicit_struct(m, (void**) obj, sizeof(%(c_name)s), &err);
 207     if (err) {
 208         goto out;
 209     }
 210     visit_get_next_type(m, (int*) &(*obj)->kind, %(c_name)s_qtypes, name, &err);
 211     if (err) {
 212         goto out_end;
 213     }
 214     switch ((*obj)->kind) {
 215 ''',
 216                 c_name=c_name(name))
 217
 218     for var in variants.variants:
 219         ret += mcgen('''
 220     case %(case)s:
 221         visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
 222         break;
 223 ''',
 224                      case=c_enum_const(variants.tag_member.type.name,
 225                                        var.name),
 226                      c_type=var.type.c_name(),
 227                      c_name=c_name(var.name))
 228
 229     ret += mcgen('''
 230     default:
 231         abort();
 232     }
 233 out_end:
 234     error_propagate(errp, err);
 235     err = NULL;
 236     visit_end_implicit_struct(m, &err);
 237 out:
 238     error_propagate(errp, err);
 239 }
 240 ''')
 241
 242     return ret
 243
 244
 245 def gen_visit_union(name, base, variants):
 246     ret = ''
 247
 248     if base:
 249         members = [m for m in base.members if m != variants.tag_member]
 250         ret += gen_visit_struct_fields(name, None, members)
 251
 252     for var in variants.variants:
 253         # Ugly special case for simple union TODO get rid of it
 254         if not var.simple_union_type():
 255             ret += gen_visit_implicit_struct(var.type)
 256
 257     ret += mcgen('''
 258
 259 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
 260 {
 261     Error *err = NULL;
 262
 263     visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
 264     if (err) {
 265         goto out;
 266     }
 267     if (*obj) {
 268 ''',
 269                  c_name=c_name(name), name=name)
 270
 271     if base:
 272         ret += mcgen('''
 273         visit_type_%(c_name)s_fields(m, obj, &err);
 274         if (err) {
 275             goto out_obj;
 276         }
 277 ''',
 278                      c_name=c_name(name))
 279
 280     tag_key = variants.tag_member.name
 281     if not variants.tag_name:
 282         # we pointlessly use a different key for simple unions
 283         tag_key = 'type'
 284     ret += mcgen('''
 285         visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "%(name)s", &err);
 286         if (err) {
 287             goto out_obj;
 288         }
 289         if (!visit_start_union(m, !!(*obj)->data, &err) || err) {
 290             goto out_obj;
 291         }
 292         switch ((*obj)->%(c_name)s) {
 293 ''',
 294                  c_type=variants.tag_member.type.c_name(),
 295                  # TODO ugly special case for simple union
 296                  # Use same tag name in C as on the wire to get rid of
 297                  # it, then: c_name=c_name(variants.tag_member.name)
 298                  c_name=c_name(variants.tag_name or 'kind'),
 299                  name=tag_key)
 300
 301     for var in variants.variants:
 302         # TODO ugly special case for simple union
 303         simple_union_type = var.simple_union_type()
 304         ret += mcgen('''
 305         case %(case)s:
 306 ''',
 307                      case=c_enum_const(variants.tag_member.type.name,
 308                                        var.name))
 309         if simple_union_type:
 310             ret += mcgen('''
 311             visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);
 312 ''',
 313                          c_type=simple_union_type.c_name(),
 314                          c_name=c_name(var.name))
 315         else:
 316             ret += mcgen('''
 317             visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);
 318 ''',
 319                          c_type=var.type.c_name(),
 320                          c_name=c_name(var.name))
 321         ret += mcgen('''
 322             break;
 323 ''')
 324
 325     ret += mcgen('''
 326         default:
 327             abort();
 328         }
 329 out_obj:
 330         error_propagate(errp, err);
 331         err = NULL;
 332         visit_end_union(m, !!(*obj)->data, &err);
 333         error_propagate(errp, err);
 334         err = NULL;
 335     }
 336     visit_end_struct(m, &err);
 337 out:
 338     error_propagate(errp, err);
 339 }
 340 ''')
 341
 342     return ret
 343
 344
 345 class QAPISchemaGenVisitVisitor(QAPISchemaVisitor):
 346     def __init__(self):
 347         self.decl = None
 348         self.defn = None
 349         self._btin = None
 350
 351     def visit_begin(self, schema):
 352         self.decl = ''
 353         self.defn = ''
 354         self._btin = guardstart('QAPI_VISIT_BUILTIN')
 355
 356     def visit_end(self):
 357         # To avoid header dependency hell, we always generate
 358         # declarations for built-in types in our header files and
 359         # simply guard them.  See also do_builtins (command line
 360         # option -b).
 361         self._btin += guardend('QAPI_VISIT_BUILTIN')
 362         self.decl = self._btin + self.decl
 363         self._btin = None
 364
 365     def visit_enum_type(self, name, info, values, prefix):
 366         self.decl += gen_visit_decl(name, scalar=True)
 367         self.defn += gen_visit_enum(name)
 368
 369     def visit_array_type(self, name, info, element_type):
 370         decl = gen_visit_decl(name)
 371         defn = gen_visit_list(name, element_type)
 372         if isinstance(element_type, QAPISchemaBuiltinType):
 373             self._btin += decl
 374             if do_builtins:
 375                 self.defn += defn
 376         else:
 377             self.decl += decl
 378             self.defn += defn
 379
 380     def visit_object_type(self, name, info, base, members, variants):
 381         if info:
 382             self.decl += gen_visit_decl(name)
 383             if variants:
 384                 assert not members      # not implemented
 385                 self.defn += gen_visit_union(name, base, variants)
 386             else:
 387                 self.defn += gen_visit_struct(name, base, members)
 388
 389     def visit_alternate_type(self, name, info, variants):
 390         self.decl += gen_visit_decl(name)
 391         self.defn += gen_visit_alternate(name, variants)
 392
 393 # If you link code generated from multiple schemata, you want only one
 394 # instance of the code for built-in types.  Generate it only when
 395 # do_builtins, enabled by command line option -b.  See also
 396 # QAPISchemaGenVisitVisitor.visit_end().
 397 do_builtins = False
 398
 399 (input_file, output_dir, do_c, do_h, prefix, opts) = \
 400     parse_command_line("b", ["builtins"])
 401
 402 for o, a in opts:
 403     if o in ("-b", "--builtins"):
 404         do_builtins = True
 405
 406 c_comment = '''
 407 /*
 408  * schema-defined QAPI visitor functions
 409  *
 410  * Copyright IBM, Corp. 2011
 411  *
 412  * Authors:
 413  *  Anthony Liguori   <aliguori@us.ibm.com>
 414  *
 415  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 416  * See the COPYING.LIB file in the top-level directory.
 417  *
 418  */
 419 '''
 420 h_comment = '''
 421 /*
 422  * schema-defined QAPI visitor functions
 423  *
 424  * Copyright IBM, Corp. 2011
 425  *
 426  * Authors:
 427  *  Anthony Liguori   <aliguori@us.ibm.com>
 428  *
 429  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 430  * See the COPYING.LIB file in the top-level directory.
 431  *
 432  */
 433 '''
 434
 435 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 436                             'qapi-visit.c', 'qapi-visit.h',
 437                             c_comment, h_comment)
 438
 439 fdef.write(mcgen('''
 440 #include "qemu-common.h"
 441 #include "%(prefix)sqapi-visit.h"
 442 ''',
 443                  prefix=prefix))
 444
 445 fdecl.write(mcgen('''
 446 #include "qapi/visitor.h"
 447 #include "%(prefix)sqapi-types.h"
 448
 449 ''',
 450                   prefix=prefix))
 451
 452 schema = QAPISchema(input_file)
 453 gen = QAPISchemaGenVisitVisitor()
 454 schema.visit(gen)
 455 fdef.write(gen.defn)
 456 fdecl.write(gen.decl)
 457
 458 close_output(fdef, fdecl)