[qemu.git] / scripts / qapi.py

#
# QAPI helper library
#
# Copyright IBM, Corp. 2011
# Copyright (c) 2013 Red Hat Inc.
#
# Authors:
#  Anthony Liguori <[email protected]>
#  Markus Armbruster <[email protected]>
#
# This work is licensed under the terms of the GNU GPL, version 2.
# See the COPYING file in the top-level directory.

from ordereddict import OrderedDict
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',
}

class QAPISchemaError(Exception):
    def __init__(self, schema, msg):
        self.fp = schema.fp
        self.msg = msg
        self.line = self.col = 1
        for ch in schema.src[0:schema.pos]:
            if ch == '\n':
                self.line += 1
                self.col = 1
            elif ch == '\t':
                self.col = (self.col + 7) % 8 + 1
            else:
                self.col += 1

    def __str__(self):
        return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg)

class QAPISchema:

    def __init__(self, fp):
        self.fp = fp
        self.src = fp.read()
        if self.src == '' or self.src[-1] != '\n':
            self.src += '\n'
        self.cursor = 0
        self.exprs = []
        self.accept()

        while self.tok != None:
            self.exprs.append(self.get_expr(False))

    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
            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()
            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 parse_schema(fp):
    try:
        schema = QAPISchema(fp)
    except QAPISchemaError, e:
        print >>sys.stderr, e
        exit(1)

    exprs = []

    for expr in schema.exprs:
        if expr.has_key('enum'):
            add_enum(expr['enum'])
        elif expr.has_key('union'):
            add_union(expr)
            add_enum('%sKind' % expr['union'])
        elif expr.has_key('type'):
            add_struct(expr)
        exprs.append(expr)

    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):
    global enum_types
    enum_types.append(name)

def is_enum(name):
    global enum_types
    return (name in enum_types)

def c_type(name):
    if name == 'str':
        return 'char *'
    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 *' % c_list_type(name[0])
    elif is_enum(name):
        return name
    elif name == None or len(name) == 0:
        return 'void'
    elif name == name.upper():
        return '%sEvent *' % camel_case(name)
    else:
        return '%s *' % name

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):
    return cgen('\n'.join(code.split('\n')[1:-1]), **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'

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))
Commit	Line	Data
0f923be2 MR	1	#
	2	# QAPI helper library
	3	#
	4	# Copyright IBM, Corp. 2011
c7a3f252	5	# Copyright (c) 2013 Red Hat Inc.
0f923be2 MR	6	#
	7	# Authors:
	8	# Anthony Liguori <[email protected]>
c7a3f252	9	# Markus Armbruster <[email protected]>
0f923be2	10	#
678e48a2 MA	11	# This work is licensed under the terms of the GNU GPL, version 2.
678e48a2 MA	12	# See the COPYING file in the top-level directory.
0f923be2 MR	13
0f923be2 MR	14	from ordereddict import OrderedDict
2caba36c	15	import sys
0f923be2	16
c0afa9c5 MR	17	builtin_types = [
	18	'str', 'int', 'number', 'bool',
	19	'int8', 'int16', 'int32', 'int64',
	20	'uint8', 'uint16', 'uint32', 'uint64'
	21	]
	22
69dd62df KW	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
2caba36c MA	38	class QAPISchemaError(Exception):
	39	def __init__(self, schema, msg):
	40	self.fp = schema.fp
	41	self.msg = msg
	42	self.line = self.col = 1
	43	for ch in schema.src[0:schema.pos]:
	44	if ch == '\n':
	45	self.line += 1
	46	self.col = 1
	47	elif ch == '\t':
	48	self.col = (self.col + 7) % 8 + 1
	49	else:
	50	self.col += 1
	51
	52	def __str__(self):
	53	return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg)
	54
c7a3f252 MA	55	class QAPISchema:
	56
	57	def __init__(self, fp):
	58	self.fp = fp
	59	self.src = fp.read()
	60	if self.src == '' or self.src[-1] != '\n':
	61	self.src += '\n'
	62	self.cursor = 0
	63	self.exprs = []
	64	self.accept()
	65
	66	while self.tok != None:
5f3cd2b7	67	self.exprs.append(self.get_expr(False))
c7a3f252 MA	68
	69	def accept(self):
	70	while True:
c7a3f252	71	self.tok = self.src[self.cursor]
2caba36c	72	self.pos = self.cursor
c7a3f252 MA	73	self.cursor += 1
	74	self.val = None
	75
f1a145e1	76	if self.tok == '#':
c7a3f252 MA	77	self.cursor = self.src.find('\n', self.cursor)
	78	elif self.tok in ['{', '}', ':', ',', '[', ']']:
	79	return
	80	elif self.tok == "'":
	81	string = ''
	82	esc = False
	83	while True:
	84	ch = self.src[self.cursor]
	85	self.cursor += 1
	86	if ch == '\n':
2caba36c MA	87	raise QAPISchemaError(self,
2caba36c MA	88	'Missing terminating "\'"')
c7a3f252 MA	89	if esc:
	90	string += ch
	91	esc = False
	92	elif ch == "\\":
	93	esc = True
	94	elif ch == "'":
	95	self.val = string
	96	return
	97	else:
	98	string += ch
	99	elif self.tok == '\n':
	100	if self.cursor == len(self.src):
	101	self.tok = None
	102	return
9213aa53 MA	103	elif not self.tok.isspace():
9213aa53 MA	104	raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
c7a3f252 MA	105
	106	def get_members(self):
	107	expr = OrderedDict()
6974ccd5 MA	108	if self.tok == '}':
	109	self.accept()
	110	return expr
	111	if self.tok != "'":
	112	raise QAPISchemaError(self, 'Expected string or "}"')
	113	while True:
c7a3f252 MA	114	key = self.val
c7a3f252 MA	115	self.accept()
6974ccd5 MA	116	if self.tok != ':':
	117	raise QAPISchemaError(self, 'Expected ":"')
	118	self.accept()
5f3cd2b7	119	expr[key] = self.get_expr(True)
6974ccd5	120	if self.tok == '}':
c7a3f252	121	self.accept()
6974ccd5 MA	122	return expr
	123	if self.tok != ',':
	124	raise QAPISchemaError(self, 'Expected "," or "}"')
	125	self.accept()
	126	if self.tok != "'":
	127	raise QAPISchemaError(self, 'Expected string')
c7a3f252 MA	128
	129	def get_values(self):
	130	expr = []
6974ccd5 MA	131	if self.tok == ']':
	132	self.accept()
	133	return expr
	134	if not self.tok in [ '{', '[', "'" ]:
	135	raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
	136	while True:
5f3cd2b7	137	expr.append(self.get_expr(True))
6974ccd5	138	if self.tok == ']':
c7a3f252	139	self.accept()
6974ccd5 MA	140	return expr
	141	if self.tok != ',':
	142	raise QAPISchemaError(self, 'Expected "," or "]"')
	143	self.accept()
c7a3f252	144
5f3cd2b7 MA	145	def get_expr(self, nested):
	146	if self.tok != '{' and not nested:
	147	raise QAPISchemaError(self, 'Expected "{"')
c7a3f252 MA	148	if self.tok == '{':
	149	self.accept()
	150	expr = self.get_members()
	151	elif self.tok == '[':
	152	self.accept()
	153	expr = self.get_values()
6974ccd5	154	elif self.tok == "'":
c7a3f252 MA	155	expr = self.val
c7a3f252 MA	156	self.accept()
6974ccd5 MA	157	else:
6974ccd5 MA	158	raise QAPISchemaError(self, 'Expected "{", "[" or string')
c7a3f252	159	return expr
bd9927fe KW	160
bd9927fe KW	161	def parse_schema(fp):
2caba36c MA	162	try:
2caba36c MA	163	schema = QAPISchema(fp)
21e0043b	164	except QAPISchemaError, e:
2caba36c MA	165	print >>sys.stderr, e
	166	exit(1)
	167
bd9927fe KW	168	exprs = []
bd9927fe KW	169
28b8bd4c MA	170	for expr in schema.exprs:
	171	if expr.has_key('enum'):
	172	add_enum(expr['enum'])
	173	elif expr.has_key('union'):
	174	add_union(expr)
	175	add_enum('%sKind' % expr['union'])
	176	elif expr.has_key('type'):
	177	add_struct(expr)
	178	exprs.append(expr)
0f923be2 MR	179
	180	return exprs
	181
	182	def parse_args(typeinfo):
b35284ea KW	183	if isinstance(typeinfo, basestring):
	184	struct = find_struct(typeinfo)
	185	assert struct != None
	186	typeinfo = struct['data']
	187
0f923be2 MR	188	for member in typeinfo:
	189	argname = member
	190	argentry = typeinfo[member]
	191	optional = False
	192	structured = False
	193	if member.startswith('*'):
	194	argname = member[1:]
	195	optional = True
	196	if isinstance(argentry, OrderedDict):
	197	structured = True
	198	yield (argname, argentry, optional, structured)
	199
	200	def de_camel_case(name):
	201	new_name = ''
	202	for ch in name:
	203	if ch.isupper() and new_name:
	204	new_name += '_'
	205	if ch == '-':
	206	new_name += '_'
	207	else:
	208	new_name += ch.lower()
	209	return new_name
	210
	211	def camel_case(name):
	212	new_name = ''
	213	first = True
	214	for ch in name:
	215	if ch in ['_', '-']:
	216	first = True
	217	elif first:
	218	new_name += ch.upper()
	219	first = False
	220	else:
	221	new_name += ch.lower()
	222	return new_name
	223
eda50a65	224	def c_var(name, protect=True):
427a1a2c BS	225	# ANSI X3J11/88-090, 3.1.1
	226	c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
	227	'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
	228	'for', 'goto', 'if', 'int', 'long', 'register', 'return',
	229	'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
	230	'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
	231	# ISO/IEC 9899:1999, 6.4.1
	232	c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
	233	# ISO/IEC 9899:2011, 6.4.1
	234	c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
	235	'_Static_assert', '_Thread_local'])
	236	# GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
	237	# excluding _.*
	238	gcc_words = set(['asm', 'typeof'])
6f88009e TS	239	# C++ ISO/IEC 14882:2003 2.11
	240	cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
	241	'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
	242	'namespace', 'new', 'operator', 'private', 'protected',
	243	'public', 'reinterpret_cast', 'static_cast', 'template',
	244	'this', 'throw', 'true', 'try', 'typeid', 'typename',
	245	'using', 'virtual', 'wchar_t',
	246	# alternative representations
	247	'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
	248	'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
1057725f	249	# namespace pollution:
8592a545	250	polluted_words = set(['unix', 'errno'])
6f88009e	251	if protect and (name in c89_words \| c99_words \| c11_words \| gcc_words \| cpp_words \| polluted_words):
427a1a2c	252	return "q_" + name
c9da228b FS	253	return name.replace('-', '_').lstrip("*")
c9da228b FS	254
eda50a65 PB	255	def c_fun(name, protect=True):
eda50a65 PB	256	return c_var(name, protect).replace('.', '_')
0f923be2 MR	257
	258	def c_list_type(name):
	259	return '%sList' % name
	260
	261	def type_name(name):
	262	if type(name) == list:
	263	return c_list_type(name[0])
	264	return name
	265
	266	enum_types = []
b35284ea	267	struct_types = []
ea66c6d8	268	union_types = []
b35284ea KW	269
	270	def add_struct(definition):
	271	global struct_types
	272	struct_types.append(definition)
	273
	274	def find_struct(name):
	275	global struct_types
	276	for struct in struct_types:
	277	if struct['type'] == name:
	278	return struct
	279	return None
0f923be2	280
ea66c6d8 KW	281	def add_union(definition):
	282	global union_types
	283	union_types.append(definition)
	284
	285	def find_union(name):
	286	global union_types
	287	for union in union_types:
	288	if union['union'] == name:
	289	return union
	290	return None
	291
0f923be2 MR	292	def add_enum(name):
	293	global enum_types
	294	enum_types.append(name)
	295
	296	def is_enum(name):
	297	global enum_types
	298	return (name in enum_types)
	299
	300	def c_type(name):
	301	if name == 'str':
	302	return 'char *'
	303	elif name == 'int':
	304	return 'int64_t'
c46f18ce LE	305	elif (name == 'int8' or name == 'int16' or name == 'int32' or
	306	name == 'int64' or name == 'uint8' or name == 'uint16' or
	307	name == 'uint32' or name == 'uint64'):
	308	return name + '_t'
092705d4 LE	309	elif name == 'size':
092705d4 LE	310	return 'uint64_t'
0f923be2 MR	311	elif name == 'bool':
	312	return 'bool'
	313	elif name == 'number':
	314	return 'double'
	315	elif type(name) == list:
	316	return '%s *' % c_list_type(name[0])
	317	elif is_enum(name):
	318	return name
	319	elif name == None or len(name) == 0:
	320	return 'void'
	321	elif name == name.upper():
	322	return '%sEvent *' % camel_case(name)
	323	else:
	324	return '%s *' % name
	325
	326	def genindent(count):
	327	ret = ""
	328	for i in range(count):
	329	ret += " "
	330	return ret
	331
	332	indent_level = 0
	333
	334	def push_indent(indent_amount=4):
	335	global indent_level
	336	indent_level += indent_amount
	337
	338	def pop_indent(indent_amount=4):
	339	global indent_level
	340	indent_level -= indent_amount
	341
	342	def cgen(code, **kwds):
	343	indent = genindent(indent_level)
	344	lines = code.split('\n')
	345	lines = map(lambda x: indent + x, lines)
	346	return '\n'.join(lines) % kwds + '\n'
	347
	348	def mcgen(code, **kwds):
	349	return cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
	350
	351	def basename(filename):
	352	return filename.split("/")[-1]
	353
	354	def guardname(filename):
d8e1f214 MR	355	guard = basename(filename).rsplit(".", 1)[0]
	356	for substr in [".", " ", "-"]:
	357	guard = guard.replace(substr, "_")
	358	return guard.upper() + '_H'
c0afa9c5 MR	359
	360	def guardstart(name):
	361	return mcgen('''
	362
	363	#ifndef %(name)s
	364	#define %(name)s
	365
	366	''',
	367	name=guardname(name))
	368
	369	def guardend(name):
	370	return mcgen('''
	371
	372	#endif /* %(name)s */
	373
	374	''',
	375	name=guardname(name))