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 ordereddict import OrderedDict
  16 from qapi import *
  17 import re
  18
  19 implicit_structs_seen = set()
  20 struct_fields_seen = set()
  21
  22 def generate_visit_implicit_struct(type):
  23     if type in implicit_structs_seen:
  24         return ''
  25     implicit_structs_seen.add(type)
  26     ret = ''
  27     if type not in struct_fields_seen:
  28         # Need a forward declaration
  29         ret += mcgen('''
  30
  31 static void visit_type_%(c_type)s_fields(Visitor *m, %(c_type)s **obj, Error **errp);
  32 ''',
  33                      c_type=type_name(type))
  34
  35     ret += mcgen('''
  36
  37 static void visit_type_implicit_%(c_type)s(Visitor *m, %(c_type)s **obj, Error **errp)
  38 {
  39     Error *err = NULL;
  40
  41     visit_start_implicit_struct(m, (void **)obj, sizeof(%(c_type)s), &err);
  42     if (!err) {
  43         visit_type_%(c_type)s_fields(m, obj, errp);
  44         visit_end_implicit_struct(m, &err);
  45     }
  46     error_propagate(errp, err);
  47 }
  48 ''',
  49                  c_type=type_name(type))
  50     return ret
  51
  52 def generate_visit_struct_fields(name, members, base = None):
  53     struct_fields_seen.add(name)
  54
  55     ret = ''
  56
  57     if base:
  58         ret += generate_visit_implicit_struct(base)
  59
  60     ret += mcgen('''
  61
  62 static void visit_type_%(name)s_fields(Visitor *m, %(name)s **obj, Error **errp)
  63 {
  64     Error *err = NULL;
  65
  66 ''',
  67                  name=c_name(name))
  68     push_indent()
  69
  70     if base:
  71         ret += mcgen('''
  72 visit_type_implicit_%(type)s(m, &(*obj)->%(c_name)s, &err);
  73 if (err) {
  74     goto out;
  75 }
  76 ''',
  77                      type=type_name(base), c_name=c_name('base'))
  78
  79     for argname, argentry, optional in parse_args(members):
  80         if optional:
  81             ret += mcgen('''
  82 visit_optional(m, &(*obj)->has_%(c_name)s, "%(name)s", &err);
  83 if (!err && (*obj)->has_%(c_name)s) {
  84 ''',
  85                          c_name=c_name(argname), name=argname)
  86             push_indent()
  87
  88         ret += mcgen('''
  89 visit_type_%(type)s(m, &(*obj)->%(c_name)s, "%(name)s", &err);
  90 ''',
  91                      type=type_name(argentry), c_name=c_name(argname),
  92                      name=argname)
  93
  94         if optional:
  95             pop_indent()
  96             ret += mcgen('''
  97 }
  98 ''')
  99         ret += mcgen('''
 100 if (err) {
 101     goto out;
 102 }
 103 ''')
 104
 105     pop_indent()
 106     if re.search('^ *goto out\\;', ret, re.MULTILINE):
 107         ret += mcgen('''
 108
 109 out:
 110 ''')
 111     ret += mcgen('''
 112     error_propagate(errp, err);
 113 }
 114 ''')
 115     return ret
 116
 117
 118 def generate_visit_struct_body(name):
 119     # FIXME: if *obj is NULL on entry, and visit_start_struct() assigns to
 120     # *obj, but then visit_type_FOO_fields() fails, we should clean up *obj
 121     # rather than leaving it non-NULL. As currently written, the caller must
 122     # call qapi_free_FOO() to avoid a memory leak of the partial FOO.
 123     ret = mcgen('''
 124     Error *err = NULL;
 125
 126     visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
 127     if (!err) {
 128         if (*obj) {
 129             visit_type_%(c_name)s_fields(m, obj, errp);
 130         }
 131         visit_end_struct(m, &err);
 132     }
 133     error_propagate(errp, err);
 134 ''',
 135                 name=name, c_name=c_name(name))
 136
 137     return ret
 138
 139 def generate_visit_struct(expr):
 140
 141     name = expr['struct']
 142     members = expr['data']
 143     base = expr.get('base')
 144
 145     ret = generate_visit_struct_fields(name, members, base)
 146
 147     ret += mcgen('''
 148
 149 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
 150 {
 151 ''',
 152                  name=c_name(name))
 153
 154     ret += generate_visit_struct_body(name)
 155
 156     ret += mcgen('''
 157 }
 158 ''')
 159     return ret
 160
 161 def generate_visit_list(name):
 162     return mcgen('''
 163
 164 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp)
 165 {
 166     Error *err = NULL;
 167     GenericList *i, **prev;
 168
 169     visit_start_list(m, name, &err);
 170     if (err) {
 171         goto out;
 172     }
 173
 174     for (prev = (GenericList **)obj;
 175          !err && (i = visit_next_list(m, prev, &err)) != NULL;
 176          prev = &i) {
 177         %(name)sList *native_i = (%(name)sList *)i;
 178         visit_type_%(name)s(m, &native_i->value, NULL, &err);
 179     }
 180
 181     error_propagate(errp, err);
 182     err = NULL;
 183     visit_end_list(m, &err);
 184 out:
 185     error_propagate(errp, err);
 186 }
 187 ''',
 188                 name=type_name(name))
 189
 190 def generate_visit_enum(name):
 191     return mcgen('''
 192
 193 void visit_type_%(c_name)s(Visitor *m, %(c_name)s *obj, const char *name, Error **errp)
 194 {
 195     visit_type_enum(m, (int *)obj, %(c_name)s_lookup, "%(name)s", name, errp);
 196 }
 197 ''',
 198                  c_name=c_name(name), name=name)
 199
 200 def generate_visit_alternate(name, members):
 201     ret = mcgen('''
 202
 203 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
 204 {
 205     Error *err = NULL;
 206
 207     visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err);
 208     if (err) {
 209         goto out;
 210     }
 211     visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err);
 212     if (err) {
 213         goto out_end;
 214     }
 215     switch ((*obj)->kind) {
 216 ''',
 217                 name=c_name(name))
 218
 219     # For alternate, always use the default enum type automatically generated
 220     # as name + 'Kind'
 221     disc_type = c_name(name) + 'Kind'
 222
 223     for key in members:
 224         assert (members[key] in builtin_types.keys()
 225             or find_struct(members[key])
 226             or find_union(members[key])
 227             or find_enum(members[key])), "Invalid alternate member"
 228
 229         enum_full_value = c_enum_const(disc_type, key)
 230         ret += mcgen('''
 231     case %(enum_full_value)s:
 232         visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
 233         break;
 234 ''',
 235                 enum_full_value = enum_full_value,
 236                 c_type = type_name(members[key]),
 237                 c_name = c_name(key))
 238
 239     ret += mcgen('''
 240     default:
 241         abort();
 242     }
 243 out_end:
 244     error_propagate(errp, err);
 245     err = NULL;
 246     visit_end_implicit_struct(m, &err);
 247 out:
 248     error_propagate(errp, err);
 249 }
 250 ''')
 251
 252     return ret
 253
 254
 255 def generate_visit_union(expr):
 256
 257     name = expr['union']
 258     members = expr['data']
 259
 260     base = expr.get('base')
 261     discriminator = expr.get('discriminator')
 262
 263     enum_define = discriminator_find_enum_define(expr)
 264     if enum_define:
 265         # Use the enum type as discriminator
 266         ret = ""
 267         disc_type = c_name(enum_define['enum_name'])
 268     else:
 269         # There will always be a discriminator in the C switch code, by default
 270         # it is an enum type generated silently
 271         ret = generate_visit_enum(name + 'Kind')
 272         disc_type = c_name(name) + 'Kind'
 273
 274     if base:
 275         assert discriminator
 276         base_fields = find_struct(base)['data'].copy()
 277         del base_fields[discriminator]
 278         ret += generate_visit_struct_fields(name, base_fields)
 279
 280     if discriminator:
 281         for key in members:
 282             ret += generate_visit_implicit_struct(members[key])
 283
 284     ret += mcgen('''
 285
 286 void visit_type_%(c_name)s(Visitor *m, %(c_name)s **obj, const char *name, Error **errp)
 287 {
 288     Error *err = NULL;
 289
 290     visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
 291     if (err) {
 292         goto out;
 293     }
 294     if (*obj) {
 295 ''',
 296                  c_name=c_name(name), name=name)
 297
 298     if base:
 299         ret += mcgen('''
 300         visit_type_%(name)s_fields(m, obj, &err);
 301         if (err) {
 302             goto out_obj;
 303         }
 304 ''',
 305                      name=c_name(name))
 306
 307     if not discriminator:
 308         tag = 'kind'
 309         disc_key = "type"
 310     else:
 311         tag = discriminator
 312         disc_key = discriminator
 313     ret += mcgen('''
 314         visit_type_%(disc_type)s(m, &(*obj)->%(c_tag)s, "%(disc_key)s", &err);
 315         if (err) {
 316             goto out_obj;
 317         }
 318         if (!visit_start_union(m, !!(*obj)->data, &err) || err) {
 319             goto out_obj;
 320         }
 321         switch ((*obj)->%(c_tag)s) {
 322 ''',
 323                  disc_type = disc_type,
 324                  c_tag=c_name(tag),
 325                  disc_key = disc_key)
 326
 327     for key in members:
 328         if not discriminator:
 329             fmt = 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);'
 330         else:
 331             fmt = 'visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);'
 332
 333         enum_full_value = c_enum_const(disc_type, key)
 334         ret += mcgen('''
 335         case %(enum_full_value)s:
 336             ''' + fmt + '''
 337             break;
 338 ''',
 339                 enum_full_value = enum_full_value,
 340                 c_type=type_name(members[key]),
 341                 c_name=c_name(key))
 342
 343     ret += mcgen('''
 344         default:
 345             abort();
 346         }
 347 out_obj:
 348         error_propagate(errp, err);
 349         err = NULL;
 350         visit_end_union(m, !!(*obj)->data, &err);
 351         error_propagate(errp, err);
 352         err = NULL;
 353     }
 354     visit_end_struct(m, &err);
 355 out:
 356     error_propagate(errp, err);
 357 }
 358 ''')
 359
 360     return ret
 361
 362 def generate_declaration(name, builtin_type=False):
 363     ret = ""
 364     if not builtin_type:
 365         name = c_name(name)
 366         ret += mcgen('''
 367
 368 void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp);
 369 ''',
 370                      name=name)
 371
 372     ret += mcgen('''
 373 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
 374 ''',
 375                  name=name)
 376
 377     return ret
 378
 379 def generate_enum_declaration(name):
 380     ret = mcgen('''
 381 void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
 382 ''',
 383                 name=c_name(name))
 384
 385     return ret
 386
 387 def generate_decl_enum(name):
 388     return mcgen('''
 389
 390 void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp);
 391 ''',
 392                  name=c_name(name))
 393
 394 do_builtins = False
 395
 396 (input_file, output_dir, do_c, do_h, prefix, opts) = \
 397     parse_command_line("b", ["builtins"])
 398
 399 for o, a in opts:
 400     if o in ("-b", "--builtins"):
 401         do_builtins = True
 402
 403 c_comment = '''
 404 /*
 405  * schema-defined QAPI visitor functions
 406  *
 407  * Copyright IBM, Corp. 2011
 408  *
 409  * Authors:
 410  *  Anthony Liguori   <aliguori@us.ibm.com>
 411  *
 412  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 413  * See the COPYING.LIB file in the top-level directory.
 414  *
 415  */
 416 '''
 417 h_comment = '''
 418 /*
 419  * schema-defined QAPI visitor functions
 420  *
 421  * Copyright IBM, Corp. 2011
 422  *
 423  * Authors:
 424  *  Anthony Liguori   <aliguori@us.ibm.com>
 425  *
 426  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 427  * See the COPYING.LIB file in the top-level directory.
 428  *
 429  */
 430 '''
 431
 432 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 433                             'qapi-visit.c', 'qapi-visit.h',
 434                             c_comment, h_comment)
 435
 436 fdef.write(mcgen('''
 437 #include "qemu-common.h"
 438 #include "%(prefix)sqapi-visit.h"
 439 ''',
 440                  prefix = prefix))
 441
 442 fdecl.write(mcgen('''
 443 #include "qapi/visitor.h"
 444 #include "%(prefix)sqapi-types.h"
 445
 446 ''',
 447                   prefix=prefix))
 448
 449 exprs = parse_schema(input_file)
 450
 451 # to avoid header dependency hell, we always generate declarations
 452 # for built-in types in our header files and simply guard them
 453 fdecl.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
 454 for typename in builtin_types.keys():
 455     fdecl.write(generate_declaration(typename, builtin_type=True))
 456 fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
 457
 458 # ...this doesn't work for cases where we link in multiple objects that
 459 # have the functions defined, so we use -b option to provide control
 460 # over these cases
 461 if do_builtins:
 462     for typename in builtin_types.keys():
 463         fdef.write(generate_visit_list(typename))
 464
 465 for expr in exprs:
 466     if expr.has_key('struct'):
 467         ret = generate_visit_struct(expr)
 468         ret += generate_visit_list(expr['struct'])
 469         fdef.write(ret)
 470
 471         ret = generate_declaration(expr['struct'])
 472         fdecl.write(ret)
 473     elif expr.has_key('union'):
 474         ret = generate_visit_union(expr)
 475         ret += generate_visit_list(expr['union'])
 476         fdef.write(ret)
 477
 478         enum_define = discriminator_find_enum_define(expr)
 479         ret = ""
 480         if not enum_define:
 481             ret = generate_decl_enum('%sKind' % expr['union'])
 482         ret += generate_declaration(expr['union'])
 483         fdecl.write(ret)
 484     elif expr.has_key('alternate'):
 485         ret = generate_visit_alternate(expr['alternate'], expr['data'])
 486         ret += generate_visit_list(expr['alternate'])
 487         fdef.write(ret)
 488
 489         ret = generate_decl_enum('%sKind' % expr['alternate'])
 490         ret += generate_declaration(expr['alternate'])
 491         fdecl.write(ret)
 492     elif expr.has_key('enum'):
 493         ret = generate_visit_list(expr['enum'])
 494         ret += generate_visit_enum(expr['enum'])
 495         fdef.write(ret)
 496
 497         ret = generate_decl_enum(expr['enum'])
 498         ret += generate_enum_declaration(expr['enum'])
 499         fdecl.write(ret)
 500
 501 close_output(fdef, fdecl)