scripts/qapi-visit.py

   1 #
   2 # QAPI visitor generator
   3 #
   4 # Copyright IBM, Corp. 2011
   5 #
   6 # Authors:
   7 #  Anthony Liguori <aliguori@us.ibm.com>
   8 #  Michael Roth    <mdroth@linux.vnet.ibm.com>
   9 #
  10 # This work is licensed under the terms of the GNU GPL, version 2.
  11 # See the COPYING file in the top-level directory.
  12
  13 from ordereddict import OrderedDict
  14 from qapi import *
  15 import sys
  16 import os
  17 import getopt
  18 import errno
  19
  20 def generate_visit_struct_fields(name, field_prefix, fn_prefix, members, base = None):
  21     substructs = []
  22     ret = ''
  23     if not fn_prefix:
  24         full_name = name
  25     else:
  26         full_name = "%s_%s" % (name, fn_prefix)
  27
  28     for argname, argentry, optional, structured in parse_args(members):
  29         if structured:
  30             if not fn_prefix:
  31                 nested_fn_prefix = argname
  32             else:
  33                 nested_fn_prefix = "%s_%s" % (fn_prefix, argname)
  34
  35             nested_field_prefix = "%s%s." % (field_prefix, argname)
  36             ret += generate_visit_struct_fields(name, nested_field_prefix,
  37                                                 nested_fn_prefix, argentry)
  38
  39     ret += mcgen('''
  40
  41 static void visit_type_%(full_name)s_fields(Visitor *m, %(name)s ** obj, Error **errp)
  42 {
  43     Error *err = NULL;
  44 ''',
  45         name=name, full_name=full_name)
  46     push_indent()
  47
  48     if base:
  49         ret += mcgen('''
  50 visit_start_implicit_struct(m, (void**) &(*obj)->%(c_name)s, sizeof(%(type)s), &err);
  51 if (!err) {
  52     visit_type_%(type)s_fields(m, &(*obj)->%(c_prefix)s%(c_name)s, &err);
  53     error_propagate(errp, err);
  54     err = NULL;
  55     visit_end_implicit_struct(m, &err);
  56 }
  57 ''',
  58                      c_prefix=c_var(field_prefix),
  59                      type=type_name(base), c_name=c_var('base'))
  60
  61     for argname, argentry, optional, structured in parse_args(members):
  62         if optional:
  63             ret += mcgen('''
  64 visit_optional(m, &(*obj)->%(c_prefix)shas_%(c_name)s, "%(name)s", &err);
  65 if ((*obj)->%(prefix)shas_%(c_name)s) {
  66 ''',
  67                          c_prefix=c_var(field_prefix), prefix=field_prefix,
  68                          c_name=c_var(argname), name=argname)
  69             push_indent()
  70
  71         if structured:
  72             ret += generate_visit_struct_body(full_name, argname, argentry)
  73         else:
  74             ret += mcgen('''
  75 visit_type_%(type)s(m, &(*obj)->%(c_prefix)s%(c_name)s, "%(name)s", &err);
  76 ''',
  77                          c_prefix=c_var(field_prefix), prefix=field_prefix,
  78                          type=type_name(argentry), c_name=c_var(argname),
  79                          name=argname)
  80
  81         if optional:
  82             pop_indent()
  83             ret += mcgen('''
  84 }
  85 ''')
  86
  87     pop_indent()
  88     ret += mcgen('''
  89
  90     error_propagate(errp, err);
  91 }
  92 ''')
  93     return ret
  94
  95
  96 def generate_visit_struct_body(field_prefix, name, members):
  97     ret = mcgen('''
  98 if (!error_is_set(errp)) {
  99 ''')
 100     push_indent()
 101
 102     if not field_prefix:
 103         full_name = name
 104     else:
 105         full_name = "%s_%s" % (field_prefix, name)
 106
 107     if len(field_prefix):
 108         ret += mcgen('''
 109 Error **errp = &err; /* from outer scope */
 110 Error *err = NULL;
 111 visit_start_struct(m, NULL, "", "%(name)s", 0, &err);
 112 ''',
 113                 name=name)
 114     else:
 115         ret += mcgen('''
 116 Error *err = NULL;
 117 visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err);
 118 ''',
 119                 name=name)
 120
 121     ret += mcgen('''
 122 if (!err) {
 123     if (*obj) {
 124         visit_type_%(name)s_fields(m, obj, &err);
 125         error_propagate(errp, err);
 126         err = NULL;
 127     }
 128 ''',
 129         name=full_name)
 130
 131     pop_indent()
 132     ret += mcgen('''
 133         /* Always call end_struct if start_struct succeeded.  */
 134         visit_end_struct(m, &err);
 135     }
 136     error_propagate(errp, err);
 137 }
 138 ''')
 139     return ret
 140
 141 def generate_visit_struct(expr):
 142
 143     name = expr['type']
 144     members = expr['data']
 145     base = expr.get('base')
 146
 147     ret = generate_visit_struct_fields(name, "", "", members, base)
 148
 149     ret += mcgen('''
 150
 151 void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp)
 152 {
 153 ''',
 154                 name=name)
 155
 156     push_indent()
 157     ret += generate_visit_struct_body("", name, members)
 158     pop_indent()
 159
 160     ret += mcgen('''
 161 }
 162 ''')
 163     return ret
 164
 165 def generate_visit_list(name, members):
 166     return mcgen('''
 167
 168 void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp)
 169 {
 170     GenericList *i, **prev = (GenericList **)obj;
 171     Error *err = NULL;
 172
 173     if (!error_is_set(errp)) {
 174         visit_start_list(m, name, &err);
 175         if (!err) {
 176             for (; (i = visit_next_list(m, prev, &err)) != NULL; prev = &i) {
 177                 %(name)sList *native_i = (%(name)sList *)i;
 178                 visit_type_%(name)s(m, &native_i->value, NULL, &err);
 179             }
 180             error_propagate(errp, err);
 181             err = NULL;
 182
 183             /* Always call end_list if start_list succeeded.  */
 184             visit_end_list(m, &err);
 185         }
 186         error_propagate(errp, err);
 187     }
 188 }
 189 ''',
 190                 name=name)
 191
 192 def generate_visit_enum(name, members):
 193     return mcgen('''
 194
 195 void visit_type_%(name)s(Visitor *m, %(name)s * obj, const char *name, Error **errp)
 196 {
 197     visit_type_enum(m, (int *)obj, %(name)s_lookup, "%(name)s", name, errp);
 198 }
 199 ''',
 200                  name=name)
 201
 202 def generate_visit_anon_union(name, members):
 203     ret = mcgen('''
 204
 205 void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp)
 206 {
 207     Error *err = NULL;
 208
 209     if (!error_is_set(errp)) {
 210         visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err);
 211         visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err);
 212         switch ((*obj)->kind) {
 213 ''',
 214     name=name)
 215
 216     # For anon union, always use the default enum type automatically generated
 217     # as "'%sKind' % (name)"
 218     disc_type = '%sKind' % (name)
 219
 220     for key in members:
 221         assert (members[key] in builtin_types
 222             or find_struct(members[key])
 223             or find_union(members[key])), "Invalid anonymous union member"
 224
 225         enum_full_value = generate_enum_full_value(disc_type, key)
 226         ret += mcgen('''
 227         case %(enum_full_value)s:
 228             visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
 229             break;
 230 ''',
 231                 enum_full_value = enum_full_value,
 232                 c_type = type_name(members[key]),
 233                 c_name = c_fun(key))
 234
 235     ret += mcgen('''
 236         default:
 237             abort();
 238         }
 239         error_propagate(errp, err);
 240         err = NULL;
 241         visit_end_implicit_struct(m, &err);
 242     }
 243 }
 244 ''')
 245
 246     return ret
 247
 248
 249 def generate_visit_union(expr):
 250
 251     name = expr['union']
 252     members = expr['data']
 253
 254     base = expr.get('base')
 255     discriminator = expr.get('discriminator')
 256
 257     if discriminator == {}:
 258         assert not base
 259         return generate_visit_anon_union(name, members)
 260
 261     enum_define = discriminator_find_enum_define(expr)
 262     if enum_define:
 263         # Use the enum type as discriminator
 264         ret = ""
 265         disc_type = enum_define['enum_name']
 266     else:
 267         # There will always be a discriminator in the C switch code, by default it
 268         # is an enum type generated silently as "'%sKind' % (name)"
 269         ret = generate_visit_enum('%sKind' % name, members.keys())
 270         disc_type = '%sKind' % (name)
 271
 272     if base:
 273         base_fields = find_struct(base)['data']
 274         if discriminator:
 275             base_fields = base_fields.copy()
 276             del base_fields[discriminator]
 277         ret += generate_visit_struct_fields(name, "", "", base_fields)
 278
 279     ret += mcgen('''
 280
 281 void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp)
 282 {
 283     Error *err = NULL;
 284
 285     if (!error_is_set(errp)) {
 286         visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err);
 287         if (!err) {
 288             if (*obj) {
 289 ''',
 290                  name=name)
 291
 292
 293     push_indent()
 294     push_indent()
 295     push_indent()
 296
 297     if base:
 298         ret += mcgen('''
 299     visit_type_%(name)s_fields(m, obj, &err);
 300 ''',
 301             name=name)
 302
 303     pop_indent()
 304
 305     if not discriminator:
 306         disc_key = "type"
 307     else:
 308         disc_key = discriminator
 309     ret += mcgen('''
 310         visit_type_%(disc_type)s(m, &(*obj)->kind, "%(disc_key)s", &err);
 311         if (!err) {
 312             switch ((*obj)->kind) {
 313 ''',
 314                  disc_type = disc_type,
 315                  disc_key = disc_key)
 316
 317     for key in members:
 318         if not discriminator:
 319             fmt = 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);'
 320         else:
 321             fmt = '''visit_start_implicit_struct(m, (void**) &(*obj)->%(c_name)s, sizeof(%(c_type)s), &err);
 322                 if (!err) {
 323                     visit_type_%(c_type)s_fields(m, &(*obj)->%(c_name)s, &err);
 324                     error_propagate(errp, err);
 325                     err = NULL;
 326                     visit_end_implicit_struct(m, &err);
 327                 }'''
 328
 329         enum_full_value = generate_enum_full_value(disc_type, key)
 330         ret += mcgen('''
 331             case %(enum_full_value)s:
 332                 ''' + fmt + '''
 333                 break;
 334 ''',
 335                 enum_full_value = enum_full_value,
 336                 c_type=type_name(members[key]),
 337                 c_name=c_fun(key))
 338
 339     ret += mcgen('''
 340             default:
 341                 abort();
 342             }
 343         }
 344         error_propagate(errp, err);
 345         err = NULL;
 346     }
 347 ''')
 348     pop_indent()
 349     ret += mcgen('''
 350         /* Always call end_struct if start_struct succeeded.  */
 351         visit_end_struct(m, &err);
 352     }
 353     error_propagate(errp, err);
 354 }
 355 ''')
 356
 357     pop_indent();
 358     ret += mcgen('''
 359 }
 360 ''')
 361
 362     return ret
 363
 364 def generate_declaration(name, members, genlist=True, builtin_type=False):
 365     ret = ""
 366     if not builtin_type:
 367         ret += mcgen('''
 368
 369 void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp);
 370 ''',
 371                     name=name)
 372
 373     if genlist:
 374         ret += mcgen('''
 375 void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp);
 376 ''',
 377                  name=name)
 378
 379     return ret
 380
 381 def generate_enum_declaration(name, members, genlist=True):
 382     ret = ""
 383     if genlist:
 384         ret += mcgen('''
 385 void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp);
 386 ''',
 387                      name=name)
 388
 389     return ret
 390
 391 def generate_decl_enum(name, members, genlist=True):
 392     return mcgen('''
 393
 394 void visit_type_%(name)s(Visitor *m, %(name)s * obj, const char *name, Error **errp);
 395 ''',
 396                 name=name)
 397
 398 try:
 399     opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
 400                                    ["source", "header", "builtins", "prefix=",
 401                                     "input-file=", "output-dir="])
 402 except getopt.GetoptError, err:
 403     print str(err)
 404     sys.exit(1)
 405
 406 input_file = ""
 407 output_dir = ""
 408 prefix = ""
 409 c_file = 'qapi-visit.c'
 410 h_file = 'qapi-visit.h'
 411
 412 do_c = False
 413 do_h = False
 414 do_builtins = False
 415
 416 for o, a in opts:
 417     if o in ("-p", "--prefix"):
 418         prefix = a
 419     elif o in ("-i", "--input-file"):
 420         input_file = a
 421     elif o in ("-o", "--output-dir"):
 422         output_dir = a + "/"
 423     elif o in ("-c", "--source"):
 424         do_c = True
 425     elif o in ("-h", "--header"):
 426         do_h = True
 427     elif o in ("-b", "--builtins"):
 428         do_builtins = True
 429
 430 if not do_c and not do_h:
 431     do_c = True
 432     do_h = True
 433
 434 c_file = output_dir + prefix + c_file
 435 h_file = output_dir + prefix + h_file
 436
 437 try:
 438     os.makedirs(output_dir)
 439 except os.error, e:
 440     if e.errno != errno.EEXIST:
 441         raise
 442
 443 def maybe_open(really, name, opt):
 444     if really:
 445         return open(name, opt)
 446     else:
 447         import StringIO
 448         return StringIO.StringIO()
 449
 450 fdef = maybe_open(do_c, c_file, 'w')
 451 fdecl = maybe_open(do_h, h_file, 'w')
 452
 453 fdef.write(mcgen('''
 454 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 455
 456 /*
 457  * schema-defined QAPI visitor functions
 458  *
 459  * Copyright IBM, Corp. 2011
 460  *
 461  * Authors:
 462  *  Anthony Liguori   <aliguori@us.ibm.com>
 463  *
 464  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 465  * See the COPYING.LIB file in the top-level directory.
 466  *
 467  */
 468
 469 #include "qemu-common.h"
 470 #include "%(header)s"
 471 ''',
 472                  header=basename(h_file)))
 473
 474 fdecl.write(mcgen('''
 475 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 476
 477 /*
 478  * schema-defined QAPI visitor function
 479  *
 480  * Copyright IBM, Corp. 2011
 481  *
 482  * Authors:
 483  *  Anthony Liguori   <aliguori@us.ibm.com>
 484  *
 485  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 486  * See the COPYING.LIB file in the top-level directory.
 487  *
 488  */
 489
 490 #ifndef %(guard)s
 491 #define %(guard)s
 492
 493 #include "qapi/visitor.h"
 494 #include "%(prefix)sqapi-types.h"
 495
 496 ''',
 497                   prefix=prefix, guard=guardname(h_file)))
 498
 499 exprs = parse_schema(input_file)
 500
 501 # to avoid header dependency hell, we always generate declarations
 502 # for built-in types in our header files and simply guard them
 503 fdecl.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
 504 for typename in builtin_types:
 505     fdecl.write(generate_declaration(typename, None, genlist=True,
 506                                      builtin_type=True))
 507 fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL"))
 508
 509 # ...this doesn't work for cases where we link in multiple objects that
 510 # have the functions defined, so we use -b option to provide control
 511 # over these cases
 512 if do_builtins:
 513     for typename in builtin_types:
 514         fdef.write(generate_visit_list(typename, None))
 515
 516 for expr in exprs:
 517     if expr.has_key('type'):
 518         ret = generate_visit_struct(expr)
 519         ret += generate_visit_list(expr['type'], expr['data'])
 520         fdef.write(ret)
 521
 522         ret = generate_declaration(expr['type'], expr['data'])
 523         fdecl.write(ret)
 524     elif expr.has_key('union'):
 525         ret = generate_visit_union(expr)
 526         ret += generate_visit_list(expr['union'], expr['data'])
 527         fdef.write(ret)
 528
 529         enum_define = discriminator_find_enum_define(expr)
 530         ret = ""
 531         if not enum_define:
 532             ret = generate_decl_enum('%sKind' % expr['union'],
 533                                      expr['data'].keys())
 534         ret += generate_declaration(expr['union'], expr['data'])
 535         fdecl.write(ret)
 536     elif expr.has_key('enum'):
 537         ret = generate_visit_list(expr['enum'], expr['data'])
 538         ret += generate_visit_enum(expr['enum'], expr['data'])
 539         fdef.write(ret)
 540
 541         ret = generate_decl_enum(expr['enum'], expr['data'])
 542         ret += generate_enum_declaration(expr['enum'], expr['data'])
 543         fdecl.write(ret)
 544
 545 fdecl.write('''
 546 #endif
 547 ''')
 548
 549 fdecl.flush()
 550 fdecl.close()
 551
 552 fdef.flush()
 553 fdef.close()