import
This commit is contained in:
Nguyen Anh Quynh
600
qemu/scripts/qapi.py
Normal file
600
qemu/scripts/qapi.py
Normal file
@ -0,0 +1,600 @@
|
||||
#
|
||||
# QAPI helper library
|
||||
#
|
||||
# Copyright IBM, Corp. 2011
|
||||
# Copyright (c) 2013 Red Hat Inc.
|
||||
#
|
||||
# Authors:
|
||||
# Anthony Liguori <aliguori@us.ibm.com>
|
||||
# Markus Armbruster <armbru@redhat.com>
|
||||
#
|
||||
# This work is licensed under the terms of the GNU GPL, version 2.
|
||||
# See the COPYING file in the top-level directory.
|
||||
|
||||
import re
|
||||
from ordereddict import OrderedDict
|
||||
import os
|
||||
import sys
|
||||
|
||||
builtin_types = [
|
||||
'str', 'int', 'number', 'bool',
|
||||
'int8', 'int16', 'int32', 'int64',
|
||||
'uint8', 'uint16', 'uint32', 'uint64'
|
||||
]
|
||||
|
||||
builtin_type_qtypes = {
|
||||
'str': 'QTYPE_QSTRING',
|
||||
'int': 'QTYPE_QINT',
|
||||
'number': 'QTYPE_QFLOAT',
|
||||
'bool': 'QTYPE_QBOOL',
|
||||
'int8': 'QTYPE_QINT',
|
||||
'int16': 'QTYPE_QINT',
|
||||
'int32': 'QTYPE_QINT',
|
||||
'int64': 'QTYPE_QINT',
|
||||
'uint8': 'QTYPE_QINT',
|
||||
'uint16': 'QTYPE_QINT',
|
||||
'uint32': 'QTYPE_QINT',
|
||||
'uint64': 'QTYPE_QINT',
|
||||
}
|
||||
|
||||
def error_path(parent):
|
||||
res = ""
|
||||
while parent:
|
||||
res = ("In file included from %s:%d:\n" % (parent['file'],
|
||||
parent['line'])) + res
|
||||
parent = parent['parent']
|
||||
return res
|
||||
|
||||
class QAPISchemaError(Exception):
|
||||
def __init__(self, schema, msg):
|
||||
self.input_file = schema.input_file
|
||||
self.msg = msg
|
||||
self.col = 1
|
||||
self.line = schema.line
|
||||
for ch in schema.src[schema.line_pos:schema.pos]:
|
||||
if ch == '\t':
|
||||
self.col = (self.col + 7) % 8 + 1
|
||||
else:
|
||||
self.col += 1
|
||||
self.info = schema.parent_info
|
||||
|
||||
def __str__(self):
|
||||
return error_path(self.info) + \
|
||||
"%s:%d:%d: %s" % (self.input_file, self.line, self.col, self.msg)
|
||||
|
||||
class QAPIExprError(Exception):
|
||||
def __init__(self, expr_info, msg):
|
||||
self.info = expr_info
|
||||
self.msg = msg
|
||||
|
||||
def __str__(self):
|
||||
return error_path(self.info['parent']) + \
|
||||
"%s:%d: %s" % (self.info['file'], self.info['line'], self.msg)
|
||||
|
||||
class QAPISchema:
|
||||
|
||||
def __init__(self, fp, input_relname=None, include_hist=[],
|
||||
previously_included=[], parent_info=None):
|
||||
""" include_hist is a stack used to detect inclusion cycles
|
||||
previously_included is a global state used to avoid multiple
|
||||
inclusions of the same file"""
|
||||
input_fname = os.path.abspath(fp.name)
|
||||
if input_relname is None:
|
||||
input_relname = fp.name
|
||||
self.input_dir = os.path.dirname(input_fname)
|
||||
self.input_file = input_relname
|
||||
self.include_hist = include_hist + [(input_relname, input_fname)]
|
||||
previously_included.append(input_fname)
|
||||
self.parent_info = parent_info
|
||||
self.src = fp.read()
|
||||
if self.src == '' or self.src[-1] != '\n':
|
||||
self.src += '\n'
|
||||
self.cursor = 0
|
||||
self.line = 1
|
||||
self.line_pos = 0
|
||||
self.exprs = []
|
||||
self.accept()
|
||||
|
||||
while self.tok != None:
|
||||
expr_info = {'file': input_relname, 'line': self.line, 'parent': self.parent_info}
|
||||
expr = self.get_expr(False)
|
||||
if isinstance(expr, dict) and "include" in expr:
|
||||
if len(expr) != 1:
|
||||
raise QAPIExprError(expr_info, "Invalid 'include' directive")
|
||||
include = expr["include"]
|
||||
if not isinstance(include, str):
|
||||
raise QAPIExprError(expr_info,
|
||||
'Expected a file name (string), got: %s'
|
||||
% include)
|
||||
include_path = os.path.join(self.input_dir, include)
|
||||
for elem in self.include_hist:
|
||||
if include_path == elem[1]:
|
||||
raise QAPIExprError(expr_info, "Inclusion loop for %s"
|
||||
% include)
|
||||
# skip multiple include of the same file
|
||||
if include_path in previously_included:
|
||||
continue
|
||||
try:
|
||||
fobj = open(include_path, 'r')
|
||||
except IOError, e:
|
||||
raise QAPIExprError(expr_info,
|
||||
'%s: %s' % (e.strerror, include))
|
||||
exprs_include = QAPISchema(fobj, include, self.include_hist,
|
||||
previously_included, expr_info)
|
||||
self.exprs.extend(exprs_include.exprs)
|
||||
else:
|
||||
expr_elem = {'expr': expr,
|
||||
'info': expr_info}
|
||||
self.exprs.append(expr_elem)
|
||||
|
||||
def accept(self):
|
||||
while True:
|
||||
self.tok = self.src[self.cursor]
|
||||
self.pos = self.cursor
|
||||
self.cursor += 1
|
||||
self.val = None
|
||||
|
||||
if self.tok == '#':
|
||||
self.cursor = self.src.find('\n', self.cursor)
|
||||
elif self.tok in ['{', '}', ':', ',', '[', ']']:
|
||||
return
|
||||
elif self.tok == "'":
|
||||
string = ''
|
||||
esc = False
|
||||
while True:
|
||||
ch = self.src[self.cursor]
|
||||
self.cursor += 1
|
||||
if ch == '\n':
|
||||
raise QAPISchemaError(self,
|
||||
'Missing terminating "\'"')
|
||||
if esc:
|
||||
string += ch
|
||||
esc = False
|
||||
elif ch == "\\":
|
||||
esc = True
|
||||
elif ch == "'":
|
||||
self.val = string
|
||||
return
|
||||
else:
|
||||
string += ch
|
||||
elif self.tok == '\n':
|
||||
if self.cursor == len(self.src):
|
||||
self.tok = None
|
||||
return
|
||||
self.line += 1
|
||||
self.line_pos = self.cursor
|
||||
elif not self.tok.isspace():
|
||||
raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
|
||||
|
||||
def get_members(self):
|
||||
expr = OrderedDict()
|
||||
if self.tok == '}':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != "'":
|
||||
raise QAPISchemaError(self, 'Expected string or "}"')
|
||||
while True:
|
||||
key = self.val
|
||||
self.accept()
|
||||
if self.tok != ':':
|
||||
raise QAPISchemaError(self, 'Expected ":"')
|
||||
self.accept()
|
||||
if key in expr:
|
||||
raise QAPISchemaError(self, 'Duplicate key "%s"' % key)
|
||||
expr[key] = self.get_expr(True)
|
||||
if self.tok == '}':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != ',':
|
||||
raise QAPISchemaError(self, 'Expected "," or "}"')
|
||||
self.accept()
|
||||
if self.tok != "'":
|
||||
raise QAPISchemaError(self, 'Expected string')
|
||||
|
||||
def get_values(self):
|
||||
expr = []
|
||||
if self.tok == ']':
|
||||
self.accept()
|
||||
return expr
|
||||
if not self.tok in [ '{', '[', "'" ]:
|
||||
raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
|
||||
while True:
|
||||
expr.append(self.get_expr(True))
|
||||
if self.tok == ']':
|
||||
self.accept()
|
||||
return expr
|
||||
if self.tok != ',':
|
||||
raise QAPISchemaError(self, 'Expected "," or "]"')
|
||||
self.accept()
|
||||
|
||||
def get_expr(self, nested):
|
||||
if self.tok != '{' and not nested:
|
||||
raise QAPISchemaError(self, 'Expected "{"')
|
||||
if self.tok == '{':
|
||||
self.accept()
|
||||
expr = self.get_members()
|
||||
elif self.tok == '[':
|
||||
self.accept()
|
||||
expr = self.get_values()
|
||||
elif self.tok == "'":
|
||||
expr = self.val
|
||||
self.accept()
|
||||
else:
|
||||
raise QAPISchemaError(self, 'Expected "{", "[" or string')
|
||||
return expr
|
||||
|
||||
def find_base_fields(base):
|
||||
base_struct_define = find_struct(base)
|
||||
if not base_struct_define:
|
||||
return None
|
||||
return base_struct_define['data']
|
||||
|
||||
# Return the discriminator enum define if discriminator is specified as an
|
||||
# enum type, otherwise return None.
|
||||
def discriminator_find_enum_define(expr):
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
|
||||
if not (discriminator and base):
|
||||
return None
|
||||
|
||||
base_fields = find_base_fields(base)
|
||||
if not base_fields:
|
||||
return None
|
||||
|
||||
discriminator_type = base_fields.get(discriminator)
|
||||
if not discriminator_type:
|
||||
return None
|
||||
|
||||
return find_enum(discriminator_type)
|
||||
|
||||
def check_event(expr, expr_info):
|
||||
params = expr.get('data')
|
||||
if params:
|
||||
for argname, argentry, optional, structured in parse_args(params):
|
||||
if structured:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Nested structure define in event is not "
|
||||
"supported, event '%s', argname '%s'"
|
||||
% (expr['event'], argname))
|
||||
|
||||
def check_union(expr, expr_info):
|
||||
name = expr['union']
|
||||
base = expr.get('base')
|
||||
discriminator = expr.get('discriminator')
|
||||
members = expr['data']
|
||||
|
||||
# If the object has a member 'base', its value must name a complex type.
|
||||
if base:
|
||||
base_fields = find_base_fields(base)
|
||||
if not base_fields:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Base '%s' is not a valid type"
|
||||
% base)
|
||||
|
||||
# If the union object has no member 'discriminator', it's an
|
||||
# ordinary union.
|
||||
if not discriminator:
|
||||
enum_define = None
|
||||
|
||||
# Else if the value of member 'discriminator' is {}, it's an
|
||||
# anonymous union.
|
||||
elif discriminator == {}:
|
||||
enum_define = None
|
||||
|
||||
# Else, it's a flat union.
|
||||
else:
|
||||
# The object must have a member 'base'.
|
||||
if not base:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Flat union '%s' must have a base field"
|
||||
% name)
|
||||
# The value of member 'discriminator' must name a member of the
|
||||
# base type.
|
||||
discriminator_type = base_fields.get(discriminator)
|
||||
if not discriminator_type:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator '%s' is not a member of base "
|
||||
"type '%s'"
|
||||
% (discriminator, base))
|
||||
enum_define = find_enum(discriminator_type)
|
||||
# Do not allow string discriminator
|
||||
if not enum_define:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator '%s' must be of enumeration "
|
||||
"type" % discriminator)
|
||||
|
||||
# Check every branch
|
||||
for (key, value) in members.items():
|
||||
# If this named member's value names an enum type, then all members
|
||||
# of 'data' must also be members of the enum type.
|
||||
if enum_define and not key in enum_define['enum_values']:
|
||||
raise QAPIExprError(expr_info,
|
||||
"Discriminator value '%s' is not found in "
|
||||
"enum '%s'" %
|
||||
(key, enum_define["enum_name"]))
|
||||
# Todo: add checking for values. Key is checked as above, value can be
|
||||
# also checked here, but we need more functions to handle array case.
|
||||
|
||||
def check_exprs(schema):
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if expr.has_key('union'):
|
||||
check_union(expr, expr_elem['info'])
|
||||
if expr.has_key('event'):
|
||||
check_event(expr, expr_elem['info'])
|
||||
|
||||
def parse_schema(input_file):
|
||||
try:
|
||||
schema = QAPISchema(open(input_file, "r"))
|
||||
except (QAPISchemaError, QAPIExprError), e:
|
||||
print >>sys.stderr, e
|
||||
exit(1)
|
||||
|
||||
exprs = []
|
||||
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if expr.has_key('enum'):
|
||||
add_enum(expr['enum'], expr['data'])
|
||||
elif expr.has_key('union'):
|
||||
add_union(expr)
|
||||
elif expr.has_key('type'):
|
||||
add_struct(expr)
|
||||
exprs.append(expr)
|
||||
|
||||
# Try again for hidden UnionKind enum
|
||||
for expr_elem in schema.exprs:
|
||||
expr = expr_elem['expr']
|
||||
if expr.has_key('union'):
|
||||
if not discriminator_find_enum_define(expr):
|
||||
add_enum('%sKind' % expr['union'])
|
||||
|
||||
try:
|
||||
check_exprs(schema)
|
||||
except QAPIExprError, e:
|
||||
print >>sys.stderr, e
|
||||
exit(1)
|
||||
|
||||
return exprs
|
||||
|
||||
def parse_args(typeinfo):
|
||||
if isinstance(typeinfo, basestring):
|
||||
struct = find_struct(typeinfo)
|
||||
assert struct != None
|
||||
typeinfo = struct['data']
|
||||
|
||||
for member in typeinfo:
|
||||
argname = member
|
||||
argentry = typeinfo[member]
|
||||
optional = False
|
||||
structured = False
|
||||
if member.startswith('*'):
|
||||
argname = member[1:]
|
||||
optional = True
|
||||
if isinstance(argentry, OrderedDict):
|
||||
structured = True
|
||||
yield (argname, argentry, optional, structured)
|
||||
|
||||
def de_camel_case(name):
|
||||
new_name = ''
|
||||
for ch in name:
|
||||
if ch.isupper() and new_name:
|
||||
new_name += '_'
|
||||
if ch == '-':
|
||||
new_name += '_'
|
||||
else:
|
||||
new_name += ch.lower()
|
||||
return new_name
|
||||
|
||||
def camel_case(name):
|
||||
new_name = ''
|
||||
first = True
|
||||
for ch in name:
|
||||
if ch in ['_', '-']:
|
||||
first = True
|
||||
elif first:
|
||||
new_name += ch.upper()
|
||||
first = False
|
||||
else:
|
||||
new_name += ch.lower()
|
||||
return new_name
|
||||
|
||||
def c_var(name, protect=True):
|
||||
# ANSI X3J11/88-090, 3.1.1
|
||||
c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
|
||||
'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
|
||||
'for', 'goto', 'if', 'int', 'long', 'register', 'return',
|
||||
'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
|
||||
'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
|
||||
# ISO/IEC 9899:1999, 6.4.1
|
||||
c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
|
||||
# ISO/IEC 9899:2011, 6.4.1
|
||||
c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
|
||||
'_Static_assert', '_Thread_local'])
|
||||
# GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
|
||||
# excluding _.*
|
||||
gcc_words = set(['asm', 'typeof'])
|
||||
# C++ ISO/IEC 14882:2003 2.11
|
||||
cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
|
||||
'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
|
||||
'namespace', 'new', 'operator', 'private', 'protected',
|
||||
'public', 'reinterpret_cast', 'static_cast', 'template',
|
||||
'this', 'throw', 'true', 'try', 'typeid', 'typename',
|
||||
'using', 'virtual', 'wchar_t',
|
||||
# alternative representations
|
||||
'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
|
||||
'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
|
||||
# namespace pollution:
|
||||
polluted_words = set(['unix', 'errno'])
|
||||
if protect and (name in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words):
|
||||
return "q_" + name
|
||||
return name.replace('-', '_').lstrip("*")
|
||||
|
||||
def c_fun(name, protect=True):
|
||||
return c_var(name, protect).replace('.', '_')
|
||||
|
||||
def c_list_type(name):
|
||||
return '%sList' % name
|
||||
|
||||
def type_name(name):
|
||||
if type(name) == list:
|
||||
return c_list_type(name[0])
|
||||
return name
|
||||
|
||||
enum_types = []
|
||||
struct_types = []
|
||||
union_types = []
|
||||
|
||||
def add_struct(definition):
|
||||
global struct_types
|
||||
struct_types.append(definition)
|
||||
|
||||
def find_struct(name):
|
||||
global struct_types
|
||||
for struct in struct_types:
|
||||
if struct['type'] == name:
|
||||
return struct
|
||||
return None
|
||||
|
||||
def add_union(definition):
|
||||
global union_types
|
||||
union_types.append(definition)
|
||||
|
||||
def find_union(name):
|
||||
global union_types
|
||||
for union in union_types:
|
||||
if union['union'] == name:
|
||||
return union
|
||||
return None
|
||||
|
||||
def add_enum(name, enum_values = None):
|
||||
global enum_types
|
||||
enum_types.append({"enum_name": name, "enum_values": enum_values})
|
||||
|
||||
def find_enum(name):
|
||||
global enum_types
|
||||
for enum in enum_types:
|
||||
if enum['enum_name'] == name:
|
||||
return enum
|
||||
return None
|
||||
|
||||
def is_enum(name):
|
||||
return find_enum(name) != None
|
||||
|
||||
eatspace = '\033EATSPACE.'
|
||||
|
||||
# A special suffix is added in c_type() for pointer types, and it's
|
||||
# stripped in mcgen(). So please notice this when you check the return
|
||||
# value of c_type() outside mcgen().
|
||||
def c_type(name, is_param=False):
|
||||
if name == 'str':
|
||||
if is_param:
|
||||
return 'const char *' + eatspace
|
||||
return 'char *' + eatspace
|
||||
|
||||
elif name == 'int':
|
||||
return 'int64_t'
|
||||
elif (name == 'int8' or name == 'int16' or name == 'int32' or
|
||||
name == 'int64' or name == 'uint8' or name == 'uint16' or
|
||||
name == 'uint32' or name == 'uint64'):
|
||||
return name + '_t'
|
||||
elif name == 'size':
|
||||
return 'uint64_t'
|
||||
elif name == 'bool':
|
||||
return 'bool'
|
||||
elif name == 'number':
|
||||
return 'double'
|
||||
elif type(name) == list:
|
||||
return '%s *%s' % (c_list_type(name[0]), eatspace)
|
||||
elif is_enum(name):
|
||||
return name
|
||||
elif name == None or len(name) == 0:
|
||||
return 'void'
|
||||
elif name == name.upper():
|
||||
return '%sEvent *%s' % (camel_case(name), eatspace)
|
||||
else:
|
||||
return '%s *%s' % (name, eatspace)
|
||||
|
||||
def is_c_ptr(name):
|
||||
suffix = "*" + eatspace
|
||||
return c_type(name).endswith(suffix)
|
||||
|
||||
def genindent(count):
|
||||
ret = ""
|
||||
for i in range(count):
|
||||
ret += " "
|
||||
return ret
|
||||
|
||||
indent_level = 0
|
||||
|
||||
def push_indent(indent_amount=4):
|
||||
global indent_level
|
||||
indent_level += indent_amount
|
||||
|
||||
def pop_indent(indent_amount=4):
|
||||
global indent_level
|
||||
indent_level -= indent_amount
|
||||
|
||||
def cgen(code, **kwds):
|
||||
indent = genindent(indent_level)
|
||||
lines = code.split('\n')
|
||||
lines = map(lambda x: indent + x, lines)
|
||||
return '\n'.join(lines) % kwds + '\n'
|
||||
|
||||
def mcgen(code, **kwds):
|
||||
raw = cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
|
||||
return re.sub(re.escape(eatspace) + ' *', '', raw)
|
||||
|
||||
def basename(filename):
|
||||
return filename.split("/")[-1]
|
||||
|
||||
def guardname(filename):
|
||||
guard = basename(filename).rsplit(".", 1)[0]
|
||||
for substr in [".", " ", "-"]:
|
||||
guard = guard.replace(substr, "_")
|
||||
return guard.upper() + '_H'
|
||||
|
||||
def guardstart(name):
|
||||
return mcgen('''
|
||||
|
||||
#ifndef %(name)s
|
||||
#define %(name)s
|
||||
|
||||
''',
|
||||
name=guardname(name))
|
||||
|
||||
def guardend(name):
|
||||
return mcgen('''
|
||||
|
||||
#endif /* %(name)s */
|
||||
|
||||
''',
|
||||
name=guardname(name))
|
||||
|
||||
# ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
|
||||
# ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
|
||||
# ENUM24_Name -> ENUM24_NAME
|
||||
def _generate_enum_string(value):
|
||||
c_fun_str = c_fun(value, False)
|
||||
if value.isupper():
|
||||
return c_fun_str
|
||||
|
||||
new_name = ''
|
||||
l = len(c_fun_str)
|
||||
for i in range(l):
|
||||
c = c_fun_str[i]
|
||||
# When c is upper and no "_" appears before, do more checks
|
||||
if c.isupper() and (i > 0) and c_fun_str[i - 1] != "_":
|
||||
# Case 1: next string is lower
|
||||
# Case 2: previous string is digit
|
||||
if (i < (l - 1) and c_fun_str[i + 1].islower()) or \
|
||||
c_fun_str[i - 1].isdigit():
|
||||
new_name += '_'
|
||||
new_name += c
|
||||
return new_name.lstrip('_').upper()
|
||||
|
||||
def generate_enum_full_value(enum_name, enum_value):
|
||||
abbrev_string = _generate_enum_string(enum_name)
|
||||
value_string = _generate_enum_string(enum_value)
|
||||
return "%s_%s" % (abbrev_string, value_string)
|
||||
Reference in New Issue
Block a user