scripts/qapi.py

   1 #
   2 # QAPI helper library
   3 #
   4 # Copyright IBM, Corp. 2011
   5 # Copyright (c) 2013 Red Hat Inc.
   6 #
   7 # Authors:
   8 #  Anthony Liguori <aliguori@us.ibm.com>
   9 #  Markus Armbruster <armbru@redhat.com>
  10 #
  11 # This work is licensed under the terms of the GNU GPL, version 2.
  12 # See the COPYING file in the top-level directory.
  13
  14 from ordereddict import OrderedDict
  15 import sys
  16
  17 builtin_types = [
  18     'str', 'int', 'number', 'bool',
  19     'int8', 'int16', 'int32', 'int64',
  20     'uint8', 'uint16', 'uint32', 'uint64'
  21 ]
  22
  23 builtin_type_qtypes = {
  24     'str':      'QTYPE_QSTRING',
  25     'int':      'QTYPE_QINT',
  26     'number':   'QTYPE_QFLOAT',
  27     'bool':     'QTYPE_QBOOL',
  28     'int8':     'QTYPE_QINT',
  29     'int16':    'QTYPE_QINT',
  30     'int32':    'QTYPE_QINT',
  31     'int64':    'QTYPE_QINT',
  32     'uint8':    'QTYPE_QINT',
  33     'uint16':   'QTYPE_QINT',
  34     'uint32':   'QTYPE_QINT',
  35     'uint64':   'QTYPE_QINT',
  36 }
  37
  38 class QAPISchemaError(Exception):
  39     def __init__(self, schema, msg):
  40         self.fp = schema.fp
  41         self.msg = msg
  42         self.col = 1
  43         self.line = schema.line
  44         for ch in schema.src[schema.line_pos:schema.pos]:
  45             if ch == '\t':
  46                 self.col = (self.col + 7) % 8 + 1
  47             else:
  48                 self.col += 1
  49
  50     def __str__(self):
  51         return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg)
  52
  53 class QAPIExprError(Exception):
  54     def __init__(self, expr_info, msg):
  55         self.fp = expr_info['fp']
  56         self.line = expr_info['line']
  57         self.msg = msg
  58
  59     def __str__(self):
  60         return "%s:%s: %s" % (self.fp.name, self.line, self.msg)
  61
  62 class QAPISchema:
  63
  64     def __init__(self, fp):
  65         self.fp = fp
  66         self.src = fp.read()
  67         if self.src == '' or self.src[-1] != '\n':
  68             self.src += '\n'
  69         self.cursor = 0
  70         self.line = 1
  71         self.line_pos = 0
  72         self.exprs = []
  73         self.accept()
  74
  75         while self.tok != None:
  76             expr_info = {'fp': fp, 'line': self.line}
  77             expr_elem = {'expr': self.get_expr(False),
  78                          'info': expr_info}
  79             self.exprs.append(expr_elem)
  80
  81     def accept(self):
  82         while True:
  83             self.tok = self.src[self.cursor]
  84             self.pos = self.cursor
  85             self.cursor += 1
  86             self.val = None
  87
  88             if self.tok == '#':
  89                 self.cursor = self.src.find('\n', self.cursor)
  90             elif self.tok in ['{', '}', ':', ',', '[', ']']:
  91                 return
  92             elif self.tok == "'":
  93                 string = ''
  94                 esc = False
  95                 while True:
  96                     ch = self.src[self.cursor]
  97                     self.cursor += 1
  98                     if ch == '\n':
  99                         raise QAPISchemaError(self,
 100                                               'Missing terminating "\'"')
 101                     if esc:
 102                         string += ch
 103                         esc = False
 104                     elif ch == "\\":
 105                         esc = True
 106                     elif ch == "'":
 107                         self.val = string
 108                         return
 109                     else:
 110                         string += ch
 111             elif self.tok == '\n':
 112                 if self.cursor == len(self.src):
 113                     self.tok = None
 114                     return
 115                 self.line += 1
 116                 self.line_pos = self.cursor
 117             elif not self.tok.isspace():
 118                 raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
 119
 120     def get_members(self):
 121         expr = OrderedDict()
 122         if self.tok == '}':
 123             self.accept()
 124             return expr
 125         if self.tok != "'":
 126             raise QAPISchemaError(self, 'Expected string or "}"')
 127         while True:
 128             key = self.val
 129             self.accept()
 130             if self.tok != ':':
 131                 raise QAPISchemaError(self, 'Expected ":"')
 132             self.accept()
 133             if key in expr:
 134                 raise QAPISchemaError(self, 'Duplicate key "%s"' % key)
 135             expr[key] = self.get_expr(True)
 136             if self.tok == '}':
 137                 self.accept()
 138                 return expr
 139             if self.tok != ',':
 140                 raise QAPISchemaError(self, 'Expected "," or "}"')
 141             self.accept()
 142             if self.tok != "'":
 143                 raise QAPISchemaError(self, 'Expected string')
 144
 145     def get_values(self):
 146         expr = []
 147         if self.tok == ']':
 148             self.accept()
 149             return expr
 150         if not self.tok in [ '{', '[', "'" ]:
 151             raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
 152         while True:
 153             expr.append(self.get_expr(True))
 154             if self.tok == ']':
 155                 self.accept()
 156                 return expr
 157             if self.tok != ',':
 158                 raise QAPISchemaError(self, 'Expected "," or "]"')
 159             self.accept()
 160
 161     def get_expr(self, nested):
 162         if self.tok != '{' and not nested:
 163             raise QAPISchemaError(self, 'Expected "{"')
 164         if self.tok == '{':
 165             self.accept()
 166             expr = self.get_members()
 167         elif self.tok == '[':
 168             self.accept()
 169             expr = self.get_values()
 170         elif self.tok == "'":
 171             expr = self.val
 172             self.accept()
 173         else:
 174             raise QAPISchemaError(self, 'Expected "{", "[" or string')
 175         return expr
 176
 177 def find_base_fields(base):
 178     base_struct_define = find_struct(base)
 179     if not base_struct_define:
 180         return None
 181     return base_struct_define['data']
 182
 183 # Return the discriminator enum define if discriminator is specified as an
 184 # enum type, otherwise return None.
 185 def discriminator_find_enum_define(expr):
 186     base = expr.get('base')
 187     discriminator = expr.get('discriminator')
 188
 189     if not (discriminator and base):
 190         return None
 191
 192     base_fields = find_base_fields(base)
 193     if not base_fields:
 194         return None
 195
 196     discriminator_type = base_fields.get(discriminator)
 197     if not discriminator_type:
 198         return None
 199
 200     return find_enum(discriminator_type)
 201
 202 def check_union(expr, expr_info):
 203     name = expr['union']
 204     base = expr.get('base')
 205     discriminator = expr.get('discriminator')
 206     members = expr['data']
 207
 208     # If the object has a member 'base', its value must name a complex type.
 209     if base:
 210         base_fields = find_base_fields(base)
 211         if not base_fields:
 212             raise QAPIExprError(expr_info,
 213                                 "Base '%s' is not a valid type"
 214                                 % base)
 215
 216     # If the union object has no member 'discriminator', it's an
 217     # ordinary union.
 218     if not discriminator:
 219         enum_define = None
 220
 221     # Else if the value of member 'discriminator' is {}, it's an
 222     # anonymous union.
 223     elif discriminator == {}:
 224         enum_define = None
 225
 226     # Else, it's a flat union.
 227     else:
 228         # The object must have a member 'base'.
 229         if not base:
 230             raise QAPIExprError(expr_info,
 231                                 "Flat union '%s' must have a base field"
 232                                 % name)
 233         # The value of member 'discriminator' must name a member of the
 234         # base type.
 235         discriminator_type = base_fields.get(discriminator)
 236         if not discriminator_type:
 237             raise QAPIExprError(expr_info,
 238                                 "Discriminator '%s' is not a member of base "
 239                                 "type '%s'"
 240                                 % (discriminator, base))
 241         enum_define = find_enum(discriminator_type)
 242         # Do not allow string discriminator
 243         if not enum_define:
 244             raise QAPIExprError(expr_info,
 245                                 "Discriminator '%s' must be of enumeration "
 246                                 "type" % discriminator)
 247
 248     # Check every branch
 249     for (key, value) in members.items():
 250         # If this named member's value names an enum type, then all members
 251         # of 'data' must also be members of the enum type.
 252         if enum_define and not key in enum_define['enum_values']:
 253             raise QAPIExprError(expr_info,
 254                                 "Discriminator value '%s' is not found in "
 255                                 "enum '%s'" %
 256                                 (key, enum_define["enum_name"]))
 257         # Todo: add checking for values. Key is checked as above, value can be
 258         # also checked here, but we need more functions to handle array case.
 259
 260 def check_exprs(schema):
 261     for expr_elem in schema.exprs:
 262         expr = expr_elem['expr']
 263         if expr.has_key('union'):
 264             check_union(expr, expr_elem['info'])
 265
 266 def parse_schema(fp):
 267     try:
 268         schema = QAPISchema(fp)
 269     except QAPISchemaError, e:
 270         print >>sys.stderr, e
 271         exit(1)
 272
 273     exprs = []
 274
 275     for expr_elem in schema.exprs:
 276         expr = expr_elem['expr']
 277         if expr.has_key('enum'):
 278             add_enum(expr['enum'], expr['data'])
 279         elif expr.has_key('union'):
 280             add_union(expr)
 281         elif expr.has_key('type'):
 282             add_struct(expr)
 283         exprs.append(expr)
 284
 285     # Try again for hidden UnionKind enum
 286     for expr_elem in schema.exprs:
 287         expr = expr_elem['expr']
 288         if expr.has_key('union'):
 289             if not discriminator_find_enum_define(expr):
 290                 add_enum('%sKind' % expr['union'])
 291
 292     try:
 293         check_exprs(schema)
 294     except QAPIExprError, e:
 295         print >>sys.stderr, e
 296         exit(1)
 297
 298     return exprs
 299
 300 def parse_args(typeinfo):
 301     if isinstance(typeinfo, basestring):
 302         struct = find_struct(typeinfo)
 303         assert struct != None
 304         typeinfo = struct['data']
 305
 306     for member in typeinfo:
 307         argname = member
 308         argentry = typeinfo[member]
 309         optional = False
 310         structured = False
 311         if member.startswith('*'):
 312             argname = member[1:]
 313             optional = True
 314         if isinstance(argentry, OrderedDict):
 315             structured = True
 316         yield (argname, argentry, optional, structured)
 317
 318 def de_camel_case(name):
 319     new_name = ''
 320     for ch in name:
 321         if ch.isupper() and new_name:
 322             new_name += '_'
 323         if ch == '-':
 324             new_name += '_'
 325         else:
 326             new_name += ch.lower()
 327     return new_name
 328
 329 def camel_case(name):
 330     new_name = ''
 331     first = True
 332     for ch in name:
 333         if ch in ['_', '-']:
 334             first = True
 335         elif first:
 336             new_name += ch.upper()
 337             first = False
 338         else:
 339             new_name += ch.lower()
 340     return new_name
 341
 342 def c_var(name, protect=True):
 343     # ANSI X3J11/88-090, 3.1.1
 344     c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
 345                      'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
 346                      'for', 'goto', 'if', 'int', 'long', 'register', 'return',
 347                      'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
 348                      'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
 349     # ISO/IEC 9899:1999, 6.4.1
 350     c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
 351     # ISO/IEC 9899:2011, 6.4.1
 352     c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
 353                      '_Static_assert', '_Thread_local'])
 354     # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
 355     # excluding _.*
 356     gcc_words = set(['asm', 'typeof'])
 357     # C++ ISO/IEC 14882:2003 2.11
 358     cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
 359                      'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
 360                      'namespace', 'new', 'operator', 'private', 'protected',
 361                      'public', 'reinterpret_cast', 'static_cast', 'template',
 362                      'this', 'throw', 'true', 'try', 'typeid', 'typename',
 363                      'using', 'virtual', 'wchar_t',
 364                      # alternative representations
 365                      'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
 366                      'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
 367     # namespace pollution:
 368     polluted_words = set(['unix', 'errno'])
 369     if protect and (name in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words):
 370         return "q_" + name
 371     return name.replace('-', '_').lstrip("*")
 372
 373 def c_fun(name, protect=True):
 374     return c_var(name, protect).replace('.', '_')
 375
 376 def c_list_type(name):
 377     return '%sList' % name
 378
 379 def type_name(name):
 380     if type(name) == list:
 381         return c_list_type(name[0])
 382     return name
 383
 384 enum_types = []
 385 struct_types = []
 386 union_types = []
 387
 388 def add_struct(definition):
 389     global struct_types
 390     struct_types.append(definition)
 391
 392 def find_struct(name):
 393     global struct_types
 394     for struct in struct_types:
 395         if struct['type'] == name:
 396             return struct
 397     return None
 398
 399 def add_union(definition):
 400     global union_types
 401     union_types.append(definition)
 402
 403 def find_union(name):
 404     global union_types
 405     for union in union_types:
 406         if union['union'] == name:
 407             return union
 408     return None
 409
 410 def add_enum(name, enum_values = None):
 411     global enum_types
 412     enum_types.append({"enum_name": name, "enum_values": enum_values})
 413
 414 def find_enum(name):
 415     global enum_types
 416     for enum in enum_types:
 417         if enum['enum_name'] == name:
 418             return enum
 419     return None
 420
 421 def is_enum(name):
 422     return find_enum(name) != None
 423
 424 def c_type(name):
 425     if name == 'str':
 426         return 'char *'
 427     elif name == 'int':
 428         return 'int64_t'
 429     elif (name == 'int8' or name == 'int16' or name == 'int32' or
 430           name == 'int64' or name == 'uint8' or name == 'uint16' or
 431           name == 'uint32' or name == 'uint64'):
 432         return name + '_t'
 433     elif name == 'size':
 434         return 'uint64_t'
 435     elif name == 'bool':
 436         return 'bool'
 437     elif name == 'number':
 438         return 'double'
 439     elif type(name) == list:
 440         return '%s *' % c_list_type(name[0])
 441     elif is_enum(name):
 442         return name
 443     elif name == None or len(name) == 0:
 444         return 'void'
 445     elif name == name.upper():
 446         return '%sEvent *' % camel_case(name)
 447     else:
 448         return '%s *' % name
 449
 450 def genindent(count):
 451     ret = ""
 452     for i in range(count):
 453         ret += " "
 454     return ret
 455
 456 indent_level = 0
 457
 458 def push_indent(indent_amount=4):
 459     global indent_level
 460     indent_level += indent_amount
 461
 462 def pop_indent(indent_amount=4):
 463     global indent_level
 464     indent_level -= indent_amount
 465
 466 def cgen(code, **kwds):
 467     indent = genindent(indent_level)
 468     lines = code.split('\n')
 469     lines = map(lambda x: indent + x, lines)
 470     return '\n'.join(lines) % kwds + '\n'
 471
 472 def mcgen(code, **kwds):
 473     return cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
 474
 475 def basename(filename):
 476     return filename.split("/")[-1]
 477
 478 def guardname(filename):
 479     guard = basename(filename).rsplit(".", 1)[0]
 480     for substr in [".", " ", "-"]:
 481         guard = guard.replace(substr, "_")
 482     return guard.upper() + '_H'
 483
 484 def guardstart(name):
 485     return mcgen('''
 486
 487 #ifndef %(name)s
 488 #define %(name)s
 489
 490 ''',
 491                  name=guardname(name))
 492
 493 def guardend(name):
 494     return mcgen('''
 495
 496 #endif /* %(name)s */
 497
 498 ''',
 499                  name=guardname(name))
 500
 501 # ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
 502 # ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
 503 # ENUM24_Name -> ENUM24_NAME
 504 def _generate_enum_string(value):
 505     c_fun_str = c_fun(value, False)
 506     if value.isupper():
 507         return c_fun_str
 508
 509     new_name = ''
 510     l = len(c_fun_str)
 511     for i in range(l):
 512         c = c_fun_str[i]
 513         # When c is upper and no "_" appears before, do more checks
 514         if c.isupper() and (i > 0) and c_fun_str[i - 1] != "_":
 515             # Case 1: next string is lower
 516             # Case 2: previous string is digit
 517             if (i < (l - 1) and c_fun_str[i + 1].islower()) or \
 518             c_fun_str[i - 1].isdigit():
 519                 new_name += '_'
 520         new_name += c
 521     return new_name.lstrip('_').upper()
 522
 523 def generate_enum_full_value(enum_name, enum_value):
 524     abbrev_string = _generate_enum_string(enum_name)
 525     value_string = _generate_enum_string(enum_value)
 526     return "%s_%s" % (abbrev_string, value_string)