# 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 = [
'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.fp = schema.fp
+ self.input_file = schema.input_file
self.msg = msg
self.col = 1
self.line = schema.line
self.col = (self.col + 7) % 8 + 1
else:
self.col += 1
+ self.info = schema.parent_info
def __str__(self):
- return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg)
+ 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.fp = expr_info['fp']
- self.line = expr_info['line']
+ self.info = expr_info
self.msg = msg
def __str__(self):
- return "%s:%s: %s" % (self.fp.name, self.line, self.msg)
+ return error_path(self.info['parent']) + \
+ "%s:%d: %s" % (self.info['file'], self.info['line'], self.msg)
class QAPISchema:
- def __init__(self, fp):
- self.fp = fp
+ 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.accept()
while self.tok != None:
- expr_info = {'fp': fp, 'line': self.line}
- expr_elem = {'expr': self.get_expr(False),
- 'info': expr_info}
- self.exprs.append(expr_elem)
+ 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:
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')
"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():
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(fp):
+def parse_schema(input_file):
try:
- schema = QAPISchema(fp)
- except QAPISchemaError, e:
+ schema = QAPISchema(open(input_file, "r"))
+ except (QAPISchemaError, QAPIExprError), e:
print >>sys.stderr, e
exit(1)
add_enum(expr['enum'], expr['data'])
elif expr.has_key('union'):
add_union(expr)
- add_enum('%sKind' % expr['union'])
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:
def is_enum(name):
return find_enum(name) != None
-def c_type(name):
+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':
- return 'char *'
+ 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
elif name == 'number':
return 'double'
elif type(name) == list:
- return '%s *' % c_list_type(name[0])
+ 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 *' % camel_case(name)
+ return '%sEvent *%s' % (camel_case(name), eatspace)
else:
- return '%s *' % name
+ return '%s *%s' % (name, eatspace)
+
+def is_c_ptr(name):
+ suffix = "*" + eatspace
+ return c_type(name).endswith(suffix)
def genindent(count):
ret = ""
return '\n'.join(lines) % kwds + '\n'
def mcgen(code, **kwds):
- return cgen('\n'.join(code.split('\n')[1:-1]), **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]
''',
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)
projects / qemu.git / blobdiff