import re
from ordereddict import OrderedDict
+import errno
+import getopt
import os
import sys
+import string
builtin_types = {
'str': 'QTYPE_QSTRING',
'size': 'QTYPE_QINT',
}
+# Whitelist of commands allowed to return a non-dictionary
+returns_whitelist = [
+ # From QMP:
+ 'human-monitor-command',
+ 'query-migrate-cache-size',
+ 'query-tpm-models',
+ 'query-tpm-types',
+ 'ringbuf-read',
+
+ # From QGA:
+ 'guest-file-open',
+ 'guest-fsfreeze-freeze',
+ 'guest-fsfreeze-freeze-list',
+ 'guest-fsfreeze-status',
+ 'guest-fsfreeze-thaw',
+ 'guest-get-time',
+ 'guest-set-vcpus',
+ 'guest-sync',
+ 'guest-sync-delimited',
+
+ # From qapi-schema-test:
+ 'user_def_cmd3',
+]
+
+enum_types = []
+struct_types = []
+union_types = []
+events = []
+all_names = {}
+
+#
+# Parsing the schema into expressions
+#
+
def error_path(parent):
res = ""
while parent:
class QAPISchemaError(Exception):
def __init__(self, schema, msg):
- self.input_file = schema.input_file
+ self.fname = schema.fname
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
+ self.info = schema.incl_info
def __str__(self):
return error_path(self.info) + \
- "%s:%d:%d: %s" % (self.input_file, self.line, self.col, self.msg)
+ "%s:%d:%d: %s" % (self.fname, self.line, self.col, self.msg)
class QAPIExprError(Exception):
def __init__(self, expr_info, 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
+ def __init__(self, fp, previously_included = [], incl_info = None):
+ abs_fname = os.path.abspath(fp.name)
+ fname = fp.name
+ self.fname = fname
+ previously_included.append(abs_fname)
+ self.incl_info = incl_info
self.src = fp.read()
if self.src == '' or self.src[-1] != '\n':
self.src += '\n'
self.accept()
while self.tok != None:
- expr_info = {'file': input_relname, 'line': self.line, 'parent': self.parent_info}
+ expr_info = {'file': fname, 'line': self.line,
+ 'parent': self.incl_info}
expr = self.get_expr(False)
if isinstance(expr, dict) and "include" in expr:
if len(expr) != 1:
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]:
+ incl_abs_fname = os.path.join(os.path.dirname(abs_fname),
+ include)
+ # catch inclusion cycle
+ inf = expr_info
+ while inf:
+ if incl_abs_fname == os.path.abspath(inf['file']):
raise QAPIExprError(expr_info, "Inclusion loop for %s"
% include)
+ inf = inf['parent']
# skip multiple include of the same file
- if include_path in previously_included:
+ if incl_abs_fname in previously_included:
continue
try:
- fobj = open(include_path, 'r')
+ fobj = open(incl_abs_fname, '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)
+ exprs_include = QAPISchema(fobj, previously_included,
+ expr_info)
self.exprs.extend(exprs_include.exprs)
else:
expr_elem = {'expr': expr,
raise QAPISchemaError(self,
'Missing terminating "\'"')
if esc:
- string += ch
+ if ch == 'b':
+ string += '\b'
+ elif ch == 'f':
+ string += '\f'
+ elif ch == 'n':
+ string += '\n'
+ elif ch == 'r':
+ string += '\r'
+ elif ch == 't':
+ string += '\t'
+ elif ch == 'u':
+ value = 0
+ for x in range(0, 4):
+ ch = self.src[self.cursor]
+ self.cursor += 1
+ if ch not in "0123456789abcdefABCDEF":
+ raise QAPISchemaError(self,
+ '\\u escape needs 4 '
+ 'hex digits')
+ value = (value << 4) + int(ch, 16)
+ # If Python 2 and 3 didn't disagree so much on
+ # how to handle Unicode, then we could allow
+ # Unicode string defaults. But most of QAPI is
+ # ASCII-only, so we aren't losing much for now.
+ if not value or value > 0x7f:
+ raise QAPISchemaError(self,
+ 'For now, \\u escape '
+ 'only supports non-zero '
+ 'values up to \\u007f')
+ string += chr(value)
+ elif ch in "\\/'\"":
+ string += ch
+ else:
+ raise QAPISchemaError(self,
+ "Unknown escape \\%s" %ch)
esc = False
elif ch == "\\":
esc = True
return
else:
string += ch
+ elif self.src.startswith("true", self.pos):
+ self.val = True
+ self.cursor += 3
+ return
+ elif self.src.startswith("false", self.pos):
+ self.val = False
+ self.cursor += 4
+ return
+ elif self.src.startswith("null", self.pos):
+ self.val = None
+ self.cursor += 3
+ return
elif self.tok == '\n':
if self.cursor == len(self.src):
self.tok = None
if self.tok == ']':
self.accept()
return expr
- if not self.tok in [ '{', '[', "'" ]:
- raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
+ if not self.tok in "{['tfn":
+ raise QAPISchemaError(self, 'Expected "{", "[", "]", string, '
+ 'boolean or "null"')
while True:
expr.append(self.get_expr(True))
if self.tok == ']':
elif self.tok == '[':
self.accept()
expr = self.get_values()
- elif self.tok == "'":
+ elif self.tok in "'tfn":
expr = self.val
self.accept()
else:
raise QAPISchemaError(self, 'Expected "{", "[" or string')
return expr
+#
+# Semantic analysis of schema expressions
+#
+
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 qtype of an anonymous union branch, or None on error.
-def find_anonymous_member_qtype(qapi_type):
+# Return the qtype of an alternate branch, or None on error.
+def find_alternate_member_qtype(qapi_type):
if builtin_types.has_key(qapi_type):
return builtin_types[qapi_type]
elif find_struct(qapi_type):
return "QTYPE_QDICT"
elif find_enum(qapi_type):
return "QTYPE_QSTRING"
- else:
- union = find_union(qapi_type)
- if union:
- discriminator = union.get('discriminator')
- if discriminator == {}:
- return None
- return "QTYPE_QDICT"
+ elif find_union(qapi_type):
+ return "QTYPE_QDICT"
return None
# Return the discriminator enum define if discriminator is specified as an
return find_enum(discriminator_type)
+# FIXME should enforce "other than downstream extensions [...], all
+# names should begin with a letter".
+valid_name = re.compile('^[a-zA-Z_][a-zA-Z0-9_.-]*$')
+def check_name(expr_info, source, name, allow_optional = False,
+ enum_member = False):
+ global valid_name
+ membername = name
+
+ if not isinstance(name, str):
+ raise QAPIExprError(expr_info,
+ "%s requires a string name" % source)
+ if name.startswith('*'):
+ membername = name[1:]
+ if not allow_optional:
+ raise QAPIExprError(expr_info,
+ "%s does not allow optional name '%s'"
+ % (source, name))
+ # Enum members can start with a digit, because the generated C
+ # code always prefixes it with the enum name
+ if enum_member:
+ membername = '_' + membername
+ if not valid_name.match(membername):
+ raise QAPIExprError(expr_info,
+ "%s uses invalid name '%s'" % (source, name))
+
+def add_name(name, info, meta, implicit = False):
+ global all_names
+ check_name(info, "'%s'" % meta, name)
+ # FIXME should reject names that differ only in '_' vs. '.'
+ # vs. '-', because they're liable to clash in generated C.
+ if name in all_names:
+ raise QAPIExprError(info,
+ "%s '%s' is already defined"
+ % (all_names[name], name))
+ if not implicit and name[-4:] == 'Kind':
+ raise QAPIExprError(info,
+ "%s '%s' should not end in 'Kind'"
+ % (meta, name))
+ all_names[name] = meta
+
+def add_struct(definition, info):
+ global struct_types
+ name = definition['struct']
+ add_name(name, info, 'struct')
+ struct_types.append(definition)
+
+def find_struct(name):
+ global struct_types
+ for struct in struct_types:
+ if struct['struct'] == name:
+ return struct
+ return None
+
+def add_union(definition, info):
+ global union_types
+ name = definition['union']
+ add_name(name, info, 'union')
+ 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, info, enum_values = None, implicit = False):
+ global enum_types
+ add_name(name, info, 'enum', implicit)
+ 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
+
+def check_type(expr_info, source, value, allow_array = False,
+ allow_dict = False, allow_optional = False,
+ allow_star = False, allow_metas = []):
+ global all_names
+ orig_value = value
+
+ if value is None:
+ return
+
+ if allow_star and value == '**':
+ return
+
+ # Check if array type for value is okay
+ if isinstance(value, list):
+ if not allow_array:
+ raise QAPIExprError(expr_info,
+ "%s cannot be an array" % source)
+ if len(value) != 1 or not isinstance(value[0], str):
+ raise QAPIExprError(expr_info,
+ "%s: array type must contain single type name"
+ % source)
+ value = value[0]
+ orig_value = "array of %s" %value
+
+ # Check if type name for value is okay
+ if isinstance(value, str):
+ if value == '**':
+ raise QAPIExprError(expr_info,
+ "%s uses '**' but did not request 'gen':false"
+ % source)
+ if not value in all_names:
+ raise QAPIExprError(expr_info,
+ "%s uses unknown type '%s'"
+ % (source, orig_value))
+ if not all_names[value] in allow_metas:
+ raise QAPIExprError(expr_info,
+ "%s cannot use %s type '%s'"
+ % (source, all_names[value], orig_value))
+ return
+
+ if not allow_dict:
+ raise QAPIExprError(expr_info,
+ "%s should be a type name" % source)
+
+ if not isinstance(value, OrderedDict):
+ raise QAPIExprError(expr_info,
+ "%s should be a dictionary or type name" % source)
+
+ # value is a dictionary, check that each member is okay
+ for (key, arg) in value.items():
+ check_name(expr_info, "Member of %s" % source, key,
+ allow_optional=allow_optional)
+ # Todo: allow dictionaries to represent default values of
+ # an optional argument.
+ check_type(expr_info, "Member '%s' of %s" % (key, source), arg,
+ allow_array=True, allow_star=allow_star,
+ allow_metas=['built-in', 'union', 'alternate', 'struct',
+ 'enum'])
+
+def check_member_clash(expr_info, base_name, data, source = ""):
+ base = find_struct(base_name)
+ assert base
+ base_members = base['data']
+ for key in data.keys():
+ if key.startswith('*'):
+ key = key[1:]
+ if key in base_members or "*" + key in base_members:
+ raise QAPIExprError(expr_info,
+ "Member name '%s'%s clashes with base '%s'"
+ % (key, source, base_name))
+ if base.get('base'):
+ check_member_clash(expr_info, base['base'], data, source)
+
+def check_command(expr, expr_info):
+ name = expr['command']
+ allow_star = expr.has_key('gen')
+
+ check_type(expr_info, "'data' for command '%s'" % name,
+ expr.get('data'), allow_dict=True, allow_optional=True,
+ allow_metas=['struct'], allow_star=allow_star)
+ returns_meta = ['union', 'struct']
+ if name in returns_whitelist:
+ returns_meta += ['built-in', 'alternate', 'enum']
+ check_type(expr_info, "'returns' for command '%s'" % name,
+ expr.get('returns'), allow_array=True,
+ allow_optional=True, allow_metas=returns_meta,
+ allow_star=allow_star)
+
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))
+ global events
+ name = expr['event']
+
+ if name.upper() == 'MAX':
+ raise QAPIExprError(expr_info, "Event name 'MAX' cannot be created")
+ events.append(name)
+ check_type(expr_info, "'data' for event '%s'" % name,
+ expr.get('data'), allow_dict=True, allow_optional=True,
+ allow_metas=['struct'])
def check_union(expr, expr_info):
name = expr['union']
discriminator = expr.get('discriminator')
members = expr['data']
values = { 'MAX': '(automatic)' }
- types_seen = {}
- # If the object has a member 'base', its value must name a complex type,
- # and there must be a discriminator.
- if base is not None:
- if discriminator is None:
- raise QAPIExprError(expr_info,
- "Union '%s' requires a discriminator to go "
- "along with base" %name)
+ # Two types of unions, determined by discriminator.
- # If the union object has no member 'discriminator', it's a
- # simple union. If 'discriminator' is {}, it is an anonymous union.
- if discriminator is None or discriminator == {}:
+ # With no discriminator it is a simple union.
+ if discriminator is None:
enum_define = None
+ allow_metas=['built-in', 'union', 'alternate', 'struct', 'enum']
if base is not None:
raise QAPIExprError(expr_info,
- "Union '%s' must not have a base"
+ "Simple union '%s' must not have a base"
% name)
# Else, it's a flat union.
base_fields = find_base_fields(base)
if not base_fields:
raise QAPIExprError(expr_info,
- "Base '%s' is not a valid type"
+ "Base '%s' is not a valid struct"
% base)
- # The value of member 'discriminator' must name a member of the
- # base type.
- if not isinstance(discriminator, str):
- raise QAPIExprError(expr_info,
- "Flat union '%s' discriminator must be a string"
- % name)
+ # The value of member 'discriminator' must name a non-optional
+ # member of the base struct.
+ check_name(expr_info, "Discriminator of flat union '%s'" % name,
+ discriminator)
discriminator_type = base_fields.get(discriminator)
if not discriminator_type:
raise QAPIExprError(expr_info,
"Discriminator '%s' is not a member of base "
- "type '%s'"
+ "struct '%s'"
% (discriminator, base))
enum_define = find_enum(discriminator_type)
+ allow_metas=['struct']
# Do not allow string discriminator
if not enum_define:
raise QAPIExprError(expr_info,
# Check every branch
for (key, value) in members.items():
+ check_name(expr_info, "Member of union '%s'" % name, key)
+
+ # Each value must name a known type; furthermore, in flat unions,
+ # branches must be a struct with no overlapping member names
+ check_type(expr_info, "Member '%s' of union '%s'" % (key, name),
+ value, allow_array=not base, allow_metas=allow_metas)
+ if base:
+ branch_struct = find_struct(value)
+ assert branch_struct
+ check_member_clash(expr_info, base, branch_struct['data'],
+ " of branch '%s'" % key)
+
# If the discriminator names an enum type, then all members
# of 'data' must also be members of the enum type.
if enum_define:
# Otherwise, check for conflicts in the generated enum
else:
- c_key = _generate_enum_string(key)
+ c_key = camel_to_upper(key)
if c_key in values:
raise QAPIExprError(expr_info,
"Union '%s' member '%s' clashes with '%s'"
% (name, key, values[c_key]))
values[c_key] = key
- # Ensure anonymous unions have no type conflicts.
- if discriminator == {}:
- if isinstance(value, list):
- raise QAPIExprError(expr_info,
- "Anonymous union '%s' member '%s' must "
- "not be array type" % (name, key))
- qtype = find_anonymous_member_qtype(value)
- if not qtype:
- raise QAPIExprError(expr_info,
- "Anonymous union '%s' member '%s' has "
- "invalid type '%s'" % (name, key, value))
- if qtype in types_seen:
- raise QAPIExprError(expr_info,
- "Anonymous union '%s' member '%s' can't "
- "be distinguished from member '%s'"
- % (name, key, types_seen[qtype]))
- types_seen[qtype] = key
+def check_alternate(expr, expr_info):
+ name = expr['alternate']
+ members = expr['data']
+ values = { 'MAX': '(automatic)' }
+ types_seen = {}
+
+ # Check every branch
+ for (key, value) in members.items():
+ check_name(expr_info, "Member of alternate '%s'" % name, key)
+ # Check for conflicts in the generated enum
+ c_key = camel_to_upper(key)
+ if c_key in values:
+ raise QAPIExprError(expr_info,
+ "Alternate '%s' member '%s' clashes with '%s'"
+ % (name, key, values[c_key]))
+ values[c_key] = key
+
+ # Ensure alternates have no type conflicts.
+ check_type(expr_info, "Member '%s' of alternate '%s'" % (key, name),
+ value,
+ allow_metas=['built-in', 'union', 'struct', 'enum'])
+ qtype = find_alternate_member_qtype(value)
+ assert qtype
+ if qtype in types_seen:
+ raise QAPIExprError(expr_info,
+ "Alternate '%s' member '%s' can't "
+ "be distinguished from member '%s'"
+ % (name, key, types_seen[qtype]))
+ types_seen[qtype] = key
def check_enum(expr, expr_info):
name = expr['enum']
raise QAPIExprError(expr_info,
"Enum '%s' requires an array for 'data'" % name)
for member in members:
- if not isinstance(member, str):
- raise QAPIExprError(expr_info,
- "Enum '%s' member '%s' is not a string"
- % (name, member))
- key = _generate_enum_string(member)
+ check_name(expr_info, "Member of enum '%s'" %name, member,
+ enum_member=True)
+ key = camel_to_upper(member)
if key in values:
raise QAPIExprError(expr_info,
"Enum '%s' member '%s' clashes with '%s'"
% (name, member, values[key]))
values[key] = member
-def check_exprs(schema):
- for expr_elem in schema.exprs:
+def check_struct(expr, expr_info):
+ name = expr['struct']
+ members = expr['data']
+
+ check_type(expr_info, "'data' for struct '%s'" % name, members,
+ allow_dict=True, allow_optional=True)
+ check_type(expr_info, "'base' for struct '%s'" % name, expr.get('base'),
+ allow_metas=['struct'])
+ if expr.get('base'):
+ check_member_clash(expr_info, expr['base'], expr['data'])
+
+def check_keys(expr_elem, meta, required, optional=[]):
+ expr = expr_elem['expr']
+ info = expr_elem['info']
+ name = expr[meta]
+ if not isinstance(name, str):
+ raise QAPIExprError(info,
+ "'%s' key must have a string value" % meta)
+ required = required + [ meta ]
+ for (key, value) in expr.items():
+ if not key in required and not key in optional:
+ raise QAPIExprError(info,
+ "Unknown key '%s' in %s '%s'"
+ % (key, meta, name))
+ if (key == 'gen' or key == 'success-response') and value != False:
+ raise QAPIExprError(info,
+ "'%s' of %s '%s' should only use false value"
+ % (key, meta, name))
+ for key in required:
+ if not expr.has_key(key):
+ raise QAPIExprError(info,
+ "Key '%s' is missing from %s '%s'"
+ % (key, meta, name))
+
+def check_exprs(exprs):
+ global all_names
+
+ # Learn the types and check for valid expression keys
+ for builtin in builtin_types.keys():
+ all_names[builtin] = 'built-in'
+ for expr_elem in exprs:
+ expr = expr_elem['expr']
+ info = expr_elem['info']
+ if expr.has_key('enum'):
+ check_keys(expr_elem, 'enum', ['data'])
+ add_enum(expr['enum'], info, expr['data'])
+ elif expr.has_key('union'):
+ check_keys(expr_elem, 'union', ['data'],
+ ['base', 'discriminator'])
+ add_union(expr, info)
+ elif expr.has_key('alternate'):
+ check_keys(expr_elem, 'alternate', ['data'])
+ add_name(expr['alternate'], info, 'alternate')
+ elif expr.has_key('struct'):
+ check_keys(expr_elem, 'struct', ['data'], ['base'])
+ add_struct(expr, info)
+ elif expr.has_key('command'):
+ check_keys(expr_elem, 'command', [],
+ ['data', 'returns', 'gen', 'success-response'])
+ add_name(expr['command'], info, 'command')
+ elif expr.has_key('event'):
+ check_keys(expr_elem, 'event', [], ['data'])
+ add_name(expr['event'], info, 'event')
+ else:
+ raise QAPIExprError(expr_elem['info'],
+ "Expression is missing metatype")
+
+ # Try again for hidden UnionKind enum
+ for expr_elem in exprs:
+ expr = expr_elem['expr']
+ if expr.has_key('union'):
+ if not discriminator_find_enum_define(expr):
+ add_enum('%sKind' % expr['union'], expr_elem['info'],
+ implicit=True)
+ elif expr.has_key('alternate'):
+ add_enum('%sKind' % expr['alternate'], expr_elem['info'],
+ implicit=True)
+
+ # Validate that exprs make sense
+ for expr_elem in exprs:
expr = expr_elem['expr']
info = expr_elem['info']
check_enum(expr, info)
elif expr.has_key('union'):
check_union(expr, info)
+ elif expr.has_key('alternate'):
+ check_alternate(expr, info)
+ elif expr.has_key('struct'):
+ check_struct(expr, info)
+ elif expr.has_key('command'):
+ check_command(expr, info)
elif expr.has_key('event'):
check_event(expr, info)
+ else:
+ assert False, 'unexpected meta type'
-def parse_schema(input_file):
- # First pass: read entire file into memory
- try:
- schema = QAPISchema(open(input_file, "r"))
- except (QAPISchemaError, QAPIExprError), e:
- print >>sys.stderr, e
- exit(1)
-
- exprs = []
+ return map(lambda expr_elem: expr_elem['expr'], exprs)
+def parse_schema(fname):
try:
- # Next pass: learn the types.
- for expr_elem in schema.exprs:
- expr = expr_elem['expr']
- if expr.has_key('enum'):
- add_enum(expr['enum'], expr.get('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'])
-
- # Final pass - validate that exprs make sense
- check_exprs(schema)
- except QAPIExprError, e:
+ schema = QAPISchema(open(fname, "r"))
+ return check_exprs(schema.exprs)
+ except (QAPISchemaError, QAPIExprError), e:
print >>sys.stderr, e
exit(1)
- return exprs
+#
+# Code generation helpers
+#
def parse_args(typeinfo):
if isinstance(typeinfo, str):
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
+ # Todo: allow argentry to be OrderedDict, for providing the
+ # value of an optional argument.
+ yield (argname, argentry, optional)
def camel_case(name):
new_name = ''
new_name += ch.lower()
return new_name
-def c_var(name, protect=True):
+# ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
+# ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
+# ENUM24_Name -> ENUM24_NAME
+def camel_to_upper(value):
+ c_fun_str = c_name(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 c_enum_const(type_name, const_name):
+ return camel_to_upper(type_name + '_' + const_name)
+
+c_name_trans = string.maketrans('.-', '__')
+
+# Map @name to a valid C identifier.
+# If @protect, avoid returning certain ticklish identifiers (like
+# C keywords) by prepending "q_".
+#
+# Used for converting 'name' from a 'name':'type' qapi definition
+# into a generated struct member, as well as converting type names
+# into substrings of a generated C function name.
+# '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo'
+# protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int'
+def c_name(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',
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('.', '_')
+ return name.translate(c_name_trans)
+# Map type @name to the C typedef name for the list form.
+#
+# ['Name'] -> 'NameList', ['x-Foo'] -> 'x_FooList', ['int'] -> 'intList'
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
+ return type_name(name) + 'List'
-def is_enum(name):
- return find_enum(name) != None
+# Map type @value to the C typedef form.
+#
+# Used for converting 'type' from a 'member':'type' qapi definition
+# into the alphanumeric portion of the type for a generated C parameter,
+# as well as generated C function names. See c_type() for the rest of
+# the conversion such as adding '*' on pointer types.
+# 'int' -> 'int', '[x-Foo]' -> 'x_FooList', '__a.b_c' -> '__a_b_c'
+def type_name(value):
+ if type(value) == list:
+ return c_list_type(value[0])
+ if value in builtin_types.keys():
+ return value
+ return c_name(value)
eatspace = '\033EATSPACE.'
+pointer_suffix = ' *' + eatspace
+# Map type @name to its C type expression.
+# If @is_param, const-qualify the string type.
+#
+# This function is used for computing the full C type of 'member':'name'.
# 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':
+def c_type(value, is_param=False):
+ if value == 'str':
if is_param:
- return 'const char *' + eatspace
- return 'char *' + eatspace
+ return 'const char' + pointer_suffix
+ return 'char' + pointer_suffix
- elif name == 'int':
+ elif value == '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':
+ elif (value == 'int8' or value == 'int16' or value == 'int32' or
+ value == 'int64' or value == 'uint8' or value == 'uint16' or
+ value == 'uint32' or value == 'uint64'):
+ return value + '_t'
+ elif value == 'size':
return 'uint64_t'
- elif name == 'bool':
+ elif value == 'bool':
return 'bool'
- elif name == 'number':
+ elif value == '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:
+ elif type(value) == list:
+ return c_list_type(value[0]) + pointer_suffix
+ elif is_enum(value):
+ return c_name(value)
+ elif value == None:
return 'void'
- elif name == name.upper():
- return '%sEvent *%s' % (camel_case(name), eatspace)
+ elif value in events:
+ return camel_case(value) + 'Event' + pointer_suffix
else:
- return '%s *%s' % (name, eatspace)
+ # complex type name
+ assert isinstance(value, str) and value != ""
+ return c_name(value) + pointer_suffix
-def is_c_ptr(name):
- suffix = "*" + eatspace
- return c_type(name).endswith(suffix)
+def is_c_ptr(value):
+ return c_type(value).endswith(pointer_suffix)
def genindent(count):
ret = ""
global indent_level
indent_level -= indent_amount
+# Generate @code with @kwds interpolated.
+# Obey indent_level, and strip eatspace.
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'
+ raw = code % kwds
+ if indent_level:
+ indent = genindent(indent_level)
+ raw = re.subn("^.", indent + r'\g<0>', raw, 0, re.MULTILINE)
+ raw = raw[0]
+ return re.sub(re.escape(eatspace) + ' *', '', raw)
def mcgen(code, **kwds):
- raw = cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
- return re.sub(re.escape(eatspace) + ' *', '', raw)
+ if code[0] == '\n':
+ code = code[1:]
+ return cgen(code, **kwds)
-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'
+ return c_name(filename, protect=False).upper()
def guardstart(name):
return mcgen('''
''',
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
+#
+# Common command line parsing
+#
- 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 parse_command_line(extra_options = "", extra_long_options = []):
+
+ try:
+ opts, args = getopt.gnu_getopt(sys.argv[1:],
+ "chp:o:" + extra_options,
+ ["source", "header", "prefix=",
+ "output-dir="] + extra_long_options)
+ except getopt.GetoptError, err:
+ print >>sys.stderr, "%s: %s" % (sys.argv[0], str(err))
+ sys.exit(1)
+
+ output_dir = ""
+ prefix = ""
+ do_c = False
+ do_h = False
+ extra_opts = []
+
+ for oa in opts:
+ o, a = oa
+ if o in ("-p", "--prefix"):
+ match = re.match('([A-Za-z_.-][A-Za-z0-9_.-]*)?', a)
+ if match.end() != len(a):
+ print >>sys.stderr, \
+ "%s: 'funny character '%s' in argument of --prefix" \
+ % (sys.argv[0], a[match.end()])
+ sys.exit(1)
+ prefix = a
+ elif o in ("-o", "--output-dir"):
+ output_dir = a + "/"
+ elif o in ("-c", "--source"):
+ do_c = True
+ elif o in ("-h", "--header"):
+ do_h = True
+ else:
+ extra_opts.append(oa)
+
+ if not do_c and not do_h:
+ do_c = True
+ do_h = True
+
+ if len(args) != 1:
+ print >>sys.stderr, "%s: need exactly one argument" % sys.argv[0]
+ sys.exit(1)
+ fname = args[0]
+
+ return (fname, output_dir, do_c, do_h, prefix, extra_opts)
+
+#
+# Generate output files with boilerplate
+#
+
+def open_output(output_dir, do_c, do_h, prefix, c_file, h_file,
+ c_comment, h_comment):
+ guard = guardname(prefix + h_file)
+ c_file = output_dir + prefix + c_file
+ h_file = output_dir + prefix + h_file
+
+ try:
+ os.makedirs(output_dir)
+ except os.error, e:
+ if e.errno != errno.EEXIST:
+ raise
+
+ def maybe_open(really, name, opt):
+ if really:
+ return open(name, opt)
+ else:
+ import StringIO
+ return StringIO.StringIO()
+
+ fdef = maybe_open(do_c, c_file, 'w')
+ fdecl = maybe_open(do_h, h_file, 'w')
+
+ fdef.write(mcgen('''
+/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
+%(comment)s
+''',
+ comment = c_comment))
+
+ fdecl.write(mcgen('''
+/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
+%(comment)s
+#ifndef %(guard)s
+#define %(guard)s
+
+''',
+ comment = h_comment, guard = guard))
+
+ return (fdef, fdecl)
-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)
+def close_output(fdef, fdecl):
+ fdecl.write('''
+#endif
+''')
+ fdecl.close()
+ fdef.close()
projects / qemu.git / blobdiff