scripts/qapi-types.py

   1 #
   2 # QAPI types generator
   3 #
   4 # Copyright IBM, Corp. 2011
   5 #
   6 # Authors:
   7 #  Anthony Liguori <[email protected]>
   8 #
   9 # This work is licensed under the terms of the GNU GPL, version 2.
  10 # See the COPYING file in the top-level directory.
  11
  12 from ordereddict import OrderedDict
  13 from qapi import *
  14 import sys
  15 import os
  16 import getopt
  17 import errno
  18
  19 def generate_fwd_struct(name, members, builtin_type=False):
  20     if builtin_type:
  21         return mcgen('''
  22
  23 typedef struct %(name)sList
  24 {
  25     union {
  26         %(type)s value;
  27         uint64_t padding;
  28     };
  29     struct %(name)sList *next;
  30 } %(name)sList;
  31 ''',
  32                      type=c_type(name),
  33                      name=name)
  34
  35     return mcgen('''
  36
  37 typedef struct %(name)s %(name)s;
  38
  39 typedef struct %(name)sList
  40 {
  41     union {
  42         %(name)s *value;
  43         uint64_t padding;
  44     };
  45     struct %(name)sList *next;
  46 } %(name)sList;
  47 ''',
  48                  name=name)
  49
  50 def generate_fwd_enum_struct(name, members):
  51     return mcgen('''
  52 typedef struct %(name)sList
  53 {
  54     union {
  55         %(name)s value;
  56         uint64_t padding;
  57     };
  58     struct %(name)sList *next;
  59 } %(name)sList;
  60 ''',
  61                  name=name)
  62
  63 def generate_struct_fields(members):
  64     ret = ''
  65
  66     for argname, argentry, optional, structured in parse_args(members):
  67         if optional:
  68             ret += mcgen('''
  69     bool has_%(c_name)s;
  70 ''',
  71                          c_name=c_var(argname))
  72         if structured:
  73             push_indent()
  74             ret += generate_struct({ "field": argname, "data": argentry})
  75             pop_indent()
  76         else:
  77             ret += mcgen('''
  78     %(c_type)s %(c_name)s;
  79 ''',
  80                      c_type=c_type(argentry), c_name=c_var(argname))
  81
  82     return ret
  83
  84 def generate_struct(expr):
  85
  86     structname = expr.get('type', "")
  87     fieldname = expr.get('field', "")
  88     members = expr['data']
  89     base = expr.get('base')
  90
  91     ret = mcgen('''
  92 struct %(name)s
  93 {
  94 ''',
  95           name=structname)
  96
  97     if base:
  98         ret += generate_struct_fields({'base': base})
  99
 100     ret += generate_struct_fields(members)
 101
 102     # Make sure that all structs have at least one field; this avoids
 103     # potential issues with attempting to malloc space for zero-length structs
 104     # in C, and also incompatibility with C++ (where an empty struct is size 1).
 105     if not base and not members:
 106             ret += mcgen('''
 107     char qapi_dummy_field_for_empty_struct;
 108 ''')
 109
 110     if len(fieldname):
 111         fieldname = " " + fieldname
 112     ret += mcgen('''
 113 }%(field)s;
 114 ''',
 115             field=fieldname)
 116
 117     return ret
 118
 119 def generate_enum_lookup(name, values):
 120     ret = mcgen('''
 121 const char *%(name)s_lookup[] = {
 122 ''',
 123                          name=name)
 124     i = 0
 125     for value in values:
 126         index = generate_enum_full_value(name, value)
 127         ret += mcgen('''
 128     [%(index)s] = "%(value)s",
 129 ''',
 130                      index = index, value = value)
 131
 132     max_index = generate_enum_full_value(name, 'MAX')
 133     ret += mcgen('''
 134     [%(max_index)s] = NULL,
 135 };
 136
 137 ''',
 138         max_index=max_index)
 139     return ret
 140
 141 def generate_enum(name, values):
 142     lookup_decl = mcgen('''
 143 extern const char *%(name)s_lookup[];
 144 ''',
 145                 name=name)
 146
 147     enum_decl = mcgen('''
 148 typedef enum %(name)s
 149 {
 150 ''',
 151                 name=name)
 152
 153     # append automatically generated _MAX value
 154     enum_values = values + [ 'MAX' ]
 155
 156     i = 0
 157     for value in enum_values:
 158         enum_full_value = generate_enum_full_value(name, value)
 159         enum_decl += mcgen('''
 160     %(enum_full_value)s = %(i)d,
 161 ''',
 162                      enum_full_value = enum_full_value,
 163                      i=i)
 164         i += 1
 165
 166     enum_decl += mcgen('''
 167 } %(name)s;
 168 ''',
 169                  name=name)
 170
 171     return lookup_decl + enum_decl
 172
 173 def generate_alternate_qtypes(expr):
 174
 175     name = expr['alternate']
 176     members = expr['data']
 177
 178     ret = mcgen('''
 179 const int %(name)s_qtypes[QTYPE_MAX] = {
 180 ''',
 181     name=name)
 182
 183     for key in members:
 184         qtype = find_alternate_member_qtype(members[key])
 185         assert qtype, "Invalid alternate member"
 186
 187         ret += mcgen('''
 188     [ %(qtype)s ] = %(abbrev)s_KIND_%(enum)s,
 189 ''',
 190         qtype = qtype,
 191         abbrev = de_camel_case(name).upper(),
 192         enum = c_fun(de_camel_case(key),False).upper())
 193
 194     ret += mcgen('''
 195 };
 196 ''')
 197     return ret
 198
 199
 200 def generate_union(expr, meta):
 201
 202     name = expr[meta]
 203     typeinfo = expr['data']
 204
 205     base = expr.get('base')
 206     discriminator = expr.get('discriminator')
 207
 208     enum_define = discriminator_find_enum_define(expr)
 209     if enum_define:
 210         discriminator_type_name = enum_define['enum_name']
 211     else:
 212         discriminator_type_name = '%sKind' % (name)
 213
 214     ret = mcgen('''
 215 struct %(name)s
 216 {
 217     %(discriminator_type_name)s kind;
 218     union {
 219         void *data;
 220 ''',
 221                 name=name,
 222                 discriminator_type_name=discriminator_type_name)
 223
 224     for key in typeinfo:
 225         ret += mcgen('''
 226         %(c_type)s %(c_name)s;
 227 ''',
 228                      c_type=c_type(typeinfo[key]),
 229                      c_name=c_fun(key))
 230
 231     ret += mcgen('''
 232     };
 233 ''')
 234
 235     if base:
 236         assert discriminator
 237         base_fields = find_struct(base)['data'].copy()
 238         del base_fields[discriminator]
 239         ret += generate_struct_fields(base_fields)
 240     else:
 241         assert not discriminator
 242
 243     ret += mcgen('''
 244 };
 245 ''')
 246     if meta == 'alternate':
 247         ret += mcgen('''
 248 extern const int %(name)s_qtypes[];
 249 ''',
 250             name=name)
 251
 252
 253     return ret
 254
 255 def generate_type_cleanup_decl(name):
 256     ret = mcgen('''
 257 void qapi_free_%(type)s(%(c_type)s obj);
 258 ''',
 259                 c_type=c_type(name),type=name)
 260     return ret
 261
 262 def generate_type_cleanup(name):
 263     ret = mcgen('''
 264
 265 void qapi_free_%(type)s(%(c_type)s obj)
 266 {
 267     QapiDeallocVisitor *md;
 268     Visitor *v;
 269
 270     if (!obj) {
 271         return;
 272     }
 273
 274     md = qapi_dealloc_visitor_new();
 275     v = qapi_dealloc_get_visitor(md);
 276     visit_type_%(type)s(v, &obj, NULL, NULL);
 277     qapi_dealloc_visitor_cleanup(md);
 278 }
 279 ''',
 280                 c_type=c_type(name),type=name)
 281     return ret
 282
 283
 284 try:
 285     opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
 286                                    ["source", "header", "builtins",
 287                                     "prefix=", "input-file=", "output-dir="])
 288 except getopt.GetoptError, err:
 289     print str(err)
 290     sys.exit(1)
 291
 292 output_dir = ""
 293 input_file = ""
 294 prefix = ""
 295 c_file = 'qapi-types.c'
 296 h_file = 'qapi-types.h'
 297
 298 do_c = False
 299 do_h = False
 300 do_builtins = False
 301
 302 for o, a in opts:
 303     if o in ("-p", "--prefix"):
 304         prefix = a
 305     elif o in ("-i", "--input-file"):
 306         input_file = a
 307     elif o in ("-o", "--output-dir"):
 308         output_dir = a + "/"
 309     elif o in ("-c", "--source"):
 310         do_c = True
 311     elif o in ("-h", "--header"):
 312         do_h = True
 313     elif o in ("-b", "--builtins"):
 314         do_builtins = True
 315
 316 if not do_c and not do_h:
 317     do_c = True
 318     do_h = True
 319
 320 c_file = output_dir + prefix + c_file
 321 h_file = output_dir + prefix + h_file
 322
 323 try:
 324     os.makedirs(output_dir)
 325 except os.error, e:
 326     if e.errno != errno.EEXIST:
 327         raise
 328
 329 def maybe_open(really, name, opt):
 330     if really:
 331         return open(name, opt)
 332     else:
 333         import StringIO
 334         return StringIO.StringIO()
 335
 336 fdef = maybe_open(do_c, c_file, 'w')
 337 fdecl = maybe_open(do_h, h_file, 'w')
 338
 339 fdef.write(mcgen('''
 340 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
 341
 342 /*
 343  * deallocation functions for schema-defined QAPI types
 344  *
 345  * Copyright IBM, Corp. 2011
 346  *
 347  * Authors:
 348  *  Anthony Liguori   <[email protected]>
 349  *  Michael Roth      <[email protected]>
 350  *
 351  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 352  * See the COPYING.LIB file in the top-level directory.
 353  *
 354  */
 355
 356 #include "qapi/dealloc-visitor.h"
 357 #include "%(prefix)sqapi-types.h"
 358 #include "%(prefix)sqapi-visit.h"
 359
 360 ''',             prefix=prefix))
 361
 362 fdecl.write(mcgen('''
 363 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
 364
 365 /*
 366  * schema-defined QAPI types
 367  *
 368  * Copyright IBM, Corp. 2011
 369  *
 370  * Authors:
 371  *  Anthony Liguori   <[email protected]>
 372  *
 373  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 374  * See the COPYING.LIB file in the top-level directory.
 375  *
 376  */
 377
 378 #ifndef %(guard)s
 379 #define %(guard)s
 380
 381 #include <stdbool.h>
 382 #include <stdint.h>
 383
 384 ''',
 385                   guard=guardname(h_file)))
 386
 387 exprs = parse_schema(input_file)
 388 exprs = filter(lambda expr: not expr.has_key('gen'), exprs)
 389
 390 fdecl.write(guardstart("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
 391 for typename in builtin_types.keys():
 392     fdecl.write(generate_fwd_struct(typename, None, builtin_type=True))
 393 fdecl.write(guardend("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
 394
 395 for expr in exprs:
 396     ret = "\n"
 397     if expr.has_key('type'):
 398         ret += generate_fwd_struct(expr['type'], expr['data'])
 399     elif expr.has_key('enum'):
 400         ret += generate_enum(expr['enum'], expr['data']) + "\n"
 401         ret += generate_fwd_enum_struct(expr['enum'], expr['data'])
 402         fdef.write(generate_enum_lookup(expr['enum'], expr['data']))
 403     elif expr.has_key('union'):
 404         ret += generate_fwd_struct(expr['union'], expr['data']) + "\n"
 405         enum_define = discriminator_find_enum_define(expr)
 406         if not enum_define:
 407             ret += generate_enum('%sKind' % expr['union'], expr['data'].keys())
 408             fdef.write(generate_enum_lookup('%sKind' % expr['union'],
 409                                             expr['data'].keys()))
 410     elif expr.has_key('alternate'):
 411         ret += generate_fwd_struct(expr['alternate'], expr['data']) + "\n"
 412         ret += generate_enum('%sKind' % expr['alternate'], expr['data'].keys())
 413         fdef.write(generate_enum_lookup('%sKind' % expr['alternate'],
 414                                         expr['data'].keys()))
 415         fdef.write(generate_alternate_qtypes(expr))
 416     else:
 417         continue
 418     fdecl.write(ret)
 419
 420 # to avoid header dependency hell, we always generate declarations
 421 # for built-in types in our header files and simply guard them
 422 fdecl.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
 423 for typename in builtin_types.keys():
 424     fdecl.write(generate_type_cleanup_decl(typename + "List"))
 425 fdecl.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
 426
 427 # ...this doesn't work for cases where we link in multiple objects that
 428 # have the functions defined, so we use -b option to provide control
 429 # over these cases
 430 if do_builtins:
 431     fdef.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
 432     for typename in builtin_types.keys():
 433         fdef.write(generate_type_cleanup(typename + "List"))
 434     fdef.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
 435
 436 for expr in exprs:
 437     ret = "\n"
 438     if expr.has_key('type'):
 439         ret += generate_struct(expr) + "\n"
 440         ret += generate_type_cleanup_decl(expr['type'] + "List")
 441         fdef.write(generate_type_cleanup(expr['type'] + "List") + "\n")
 442         ret += generate_type_cleanup_decl(expr['type'])
 443         fdef.write(generate_type_cleanup(expr['type']) + "\n")
 444     elif expr.has_key('union'):
 445         ret += generate_union(expr, 'union')
 446         ret += generate_type_cleanup_decl(expr['union'] + "List")
 447         fdef.write(generate_type_cleanup(expr['union'] + "List") + "\n")
 448         ret += generate_type_cleanup_decl(expr['union'])
 449         fdef.write(generate_type_cleanup(expr['union']) + "\n")
 450     elif expr.has_key('alternate'):
 451         ret += generate_union(expr, 'alternate')
 452         ret += generate_type_cleanup_decl(expr['alternate'] + "List")
 453         fdef.write(generate_type_cleanup(expr['alternate'] + "List") + "\n")
 454         ret += generate_type_cleanup_decl(expr['alternate'])
 455         fdef.write(generate_type_cleanup(expr['alternate']) + "\n")
 456     elif expr.has_key('enum'):
 457         ret += generate_type_cleanup_decl(expr['enum'] + "List")
 458         fdef.write(generate_type_cleanup(expr['enum'] + "List") + "\n")
 459     else:
 460         continue
 461     fdecl.write(ret)
 462
 463 fdecl.write('''
 464 #endif
 465 ''')
 466
 467 fdecl.flush()
 468 fdecl.close()
 469
 470 fdef.flush()
 471 fdef.close()