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