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