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