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