2011-07-19 23:50:40 +04:00
|
|
|
#
|
|
|
|
# QAPI types generator
|
|
|
|
#
|
|
|
|
# Copyright IBM, Corp. 2011
|
|
|
|
#
|
|
|
|
# Authors:
|
|
|
|
# Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
#
|
2014-03-01 11:40:34 +04:00
|
|
|
# This work is licensed under the terms of the GNU GPL, version 2.
|
|
|
|
# See the COPYING file in the top-level directory.
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
from ordereddict import OrderedDict
|
|
|
|
from qapi import *
|
|
|
|
import sys
|
|
|
|
import os
|
|
|
|
import getopt
|
|
|
|
import errno
|
|
|
|
|
2013-05-11 02:46:00 +04:00
|
|
|
def generate_fwd_struct(name, members, builtin_type=False):
|
|
|
|
if builtin_type:
|
|
|
|
return mcgen('''
|
|
|
|
|
|
|
|
typedef struct %(name)sList
|
|
|
|
{
|
2013-05-27 07:20:58 +04:00
|
|
|
union {
|
|
|
|
%(type)s value;
|
|
|
|
uint64_t padding;
|
|
|
|
};
|
2013-05-11 02:46:00 +04:00
|
|
|
struct %(name)sList *next;
|
|
|
|
} %(name)sList;
|
|
|
|
''',
|
|
|
|
type=c_type(name),
|
|
|
|
name=name)
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
return mcgen('''
|
2013-05-11 02:46:00 +04:00
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
typedef struct %(name)s %(name)s;
|
|
|
|
|
|
|
|
typedef struct %(name)sList
|
|
|
|
{
|
2013-05-27 07:20:58 +04:00
|
|
|
union {
|
|
|
|
%(name)s *value;
|
|
|
|
uint64_t padding;
|
|
|
|
};
|
2011-07-19 23:50:40 +04:00
|
|
|
struct %(name)sList *next;
|
|
|
|
} %(name)sList;
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
qapi: generate list struct and visit_list for enum
Currently, if we define an 'enum' and use it in one command's
data, list struct for enum could not be generated, but it's
used in qmp function.
For example: KeyCodesList could not be generated.
>>> qapi-schema.json:
{ 'enum': 'KeyCodes',
'data': [ 'shift', 'alt' ... ] }
{ 'command': 'sendkey',
'data': { 'keys': ['KeyCodes'], '*hold-time': 'int' } }
>>> qmp-command.h:
void qmp_sendkey(KeyCodesList * keys, bool has_hold_time, int64_t
hold_time, Error **errp);
This patch lets qapi generate list struct and visit_list for enum.
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2012-08-31 06:56:23 +04:00
|
|
|
def generate_fwd_enum_struct(name, members):
|
|
|
|
return mcgen('''
|
|
|
|
typedef struct %(name)sList
|
|
|
|
{
|
2013-09-01 02:36:17 +04:00
|
|
|
union {
|
|
|
|
%(name)s value;
|
|
|
|
uint64_t padding;
|
|
|
|
};
|
qapi: generate list struct and visit_list for enum
Currently, if we define an 'enum' and use it in one command's
data, list struct for enum could not be generated, but it's
used in qmp function.
For example: KeyCodesList could not be generated.
>>> qapi-schema.json:
{ 'enum': 'KeyCodes',
'data': [ 'shift', 'alt' ... ] }
{ 'command': 'sendkey',
'data': { 'keys': ['KeyCodes'], '*hold-time': 'int' } }
>>> qmp-command.h:
void qmp_sendkey(KeyCodesList * keys, bool has_hold_time, int64_t
hold_time, Error **errp);
This patch lets qapi generate list struct and visit_list for enum.
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2012-08-31 06:56:23 +04:00
|
|
|
struct %(name)sList *next;
|
|
|
|
} %(name)sList;
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
2013-07-02 14:18:18 +04:00
|
|
|
def generate_struct_fields(members):
|
|
|
|
ret = ''
|
2011-07-19 23:50:40 +04:00
|
|
|
|
2015-05-04 18:05:33 +03:00
|
|
|
for argname, argentry, optional in parse_args(members):
|
2011-07-19 23:50:40 +04:00
|
|
|
if optional:
|
|
|
|
ret += mcgen('''
|
|
|
|
bool has_%(c_name)s;
|
|
|
|
''',
|
|
|
|
c_name=c_var(argname))
|
2015-05-04 18:05:33 +03:00
|
|
|
ret += mcgen('''
|
2011-07-19 23:50:40 +04:00
|
|
|
%(c_type)s %(c_name)s;
|
|
|
|
''',
|
|
|
|
c_type=c_type(argentry), c_name=c_var(argname))
|
|
|
|
|
2013-07-02 14:18:18 +04:00
|
|
|
return ret
|
|
|
|
|
2013-09-18 19:22:02 +04:00
|
|
|
def generate_struct(expr):
|
|
|
|
|
2015-05-04 18:05:25 +03:00
|
|
|
structname = expr.get('struct', "")
|
2013-09-18 19:22:02 +04:00
|
|
|
fieldname = expr.get('field', "")
|
|
|
|
members = expr['data']
|
2013-09-19 13:56:36 +04:00
|
|
|
base = expr.get('base')
|
2013-09-18 19:22:02 +04:00
|
|
|
|
2013-07-02 14:18:18 +04:00
|
|
|
ret = mcgen('''
|
|
|
|
struct %(name)s
|
|
|
|
{
|
|
|
|
''',
|
|
|
|
name=structname)
|
|
|
|
|
2013-09-19 13:56:36 +04:00
|
|
|
if base:
|
|
|
|
ret += generate_struct_fields({'base': base})
|
|
|
|
|
2013-07-02 14:18:18 +04:00
|
|
|
ret += generate_struct_fields(members)
|
|
|
|
|
2015-01-20 18:19:32 +03:00
|
|
|
# Make sure that all structs have at least one field; this avoids
|
|
|
|
# potential issues with attempting to malloc space for zero-length structs
|
|
|
|
# in C, and also incompatibility with C++ (where an empty struct is size 1).
|
|
|
|
if not base and not members:
|
|
|
|
ret += mcgen('''
|
|
|
|
char qapi_dummy_field_for_empty_struct;
|
|
|
|
''')
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
if len(fieldname):
|
|
|
|
fieldname = " " + fieldname
|
|
|
|
ret += mcgen('''
|
|
|
|
}%(field)s;
|
|
|
|
''',
|
|
|
|
field=fieldname)
|
|
|
|
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def generate_enum_lookup(name, values):
|
|
|
|
ret = mcgen('''
|
|
|
|
const char *%(name)s_lookup[] = {
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
i = 0
|
|
|
|
for value in values:
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
index = generate_enum_full_value(name, value)
|
2011-07-19 23:50:40 +04:00
|
|
|
ret += mcgen('''
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
[%(index)s] = "%(value)s",
|
2011-07-19 23:50:40 +04:00
|
|
|
''',
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
index = index, value = value)
|
2011-07-19 23:50:40 +04:00
|
|
|
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
max_index = generate_enum_full_value(name, 'MAX')
|
2011-07-19 23:50:40 +04:00
|
|
|
ret += mcgen('''
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
[%(max_index)s] = NULL,
|
2011-07-19 23:50:40 +04:00
|
|
|
};
|
|
|
|
|
qapi-types: add C99 index names to arrays
It's not easy to figure out how monitor translates
strings: most QEMU code deals with translated indexes,
these are translated using _lookup arrays,
so you need to find the array name, and find the
appropriate offset.
This patch adds C99 indexes to lookup arrays, which makes it possible to
find the correct key using simple grep, and see that the matching is
correct at a glance.
Example:
Before:
const char *MigrationCapability_lookup[] = {
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
NULL,
};
After:
const char *MigrationCapability_lookup[] = {
[MIGRATION_CAPABILITY_XBZRLE] = "xbzrle",
[MIGRATION_CAPABILITY_RDMA_PIN_ALL] = "rdma-pin-all",
[MIGRATION_CAPABILITY_AUTO_CONVERGE] = "auto-converge",
[MIGRATION_CAPABILITY_ZERO_BLOCKS] = "zero-blocks",
[MIGRATION_CAPABILITY_MAX] = NULL,
};
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-19 13:13:10 +03:00
|
|
|
''',
|
|
|
|
max_index=max_index)
|
2011-07-19 23:50:40 +04:00
|
|
|
return ret
|
|
|
|
|
|
|
|
def generate_enum(name, values):
|
|
|
|
lookup_decl = mcgen('''
|
|
|
|
extern const char *%(name)s_lookup[];
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
|
|
|
enum_decl = mcgen('''
|
|
|
|
typedef enum %(name)s
|
|
|
|
{
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
2011-09-30 19:43:27 +04:00
|
|
|
# append automatically generated _MAX value
|
|
|
|
enum_values = values + [ 'MAX' ]
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
i = 0
|
2011-09-30 19:43:27 +04:00
|
|
|
for value in enum_values:
|
2014-03-05 06:44:36 +04:00
|
|
|
enum_full_value = generate_enum_full_value(name, value)
|
2011-07-19 23:50:40 +04:00
|
|
|
enum_decl += mcgen('''
|
2014-03-05 06:44:36 +04:00
|
|
|
%(enum_full_value)s = %(i)d,
|
2011-07-19 23:50:40 +04:00
|
|
|
''',
|
2014-03-05 06:44:36 +04:00
|
|
|
enum_full_value = enum_full_value,
|
2011-07-19 23:50:40 +04:00
|
|
|
i=i)
|
|
|
|
i += 1
|
|
|
|
|
|
|
|
enum_decl += mcgen('''
|
|
|
|
} %(name)s;
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
|
|
|
return lookup_decl + enum_decl
|
|
|
|
|
2015-05-04 18:05:10 +03:00
|
|
|
def generate_alternate_qtypes(expr):
|
2013-07-08 18:14:21 +04:00
|
|
|
|
2015-05-04 18:05:13 +03:00
|
|
|
name = expr['alternate']
|
2013-07-08 18:14:21 +04:00
|
|
|
members = expr['data']
|
|
|
|
|
|
|
|
ret = mcgen('''
|
|
|
|
const int %(name)s_qtypes[QTYPE_MAX] = {
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
|
|
|
for key in members:
|
2015-05-04 18:05:10 +03:00
|
|
|
qtype = find_alternate_member_qtype(members[key])
|
2015-05-04 18:05:13 +03:00
|
|
|
assert qtype, "Invalid alternate member"
|
2013-07-08 18:14:21 +04:00
|
|
|
|
|
|
|
ret += mcgen('''
|
|
|
|
[ %(qtype)s ] = %(abbrev)s_KIND_%(enum)s,
|
|
|
|
''',
|
|
|
|
qtype = qtype,
|
|
|
|
abbrev = de_camel_case(name).upper(),
|
|
|
|
enum = c_fun(de_camel_case(key),False).upper())
|
|
|
|
|
|
|
|
ret += mcgen('''
|
|
|
|
};
|
|
|
|
''')
|
|
|
|
return ret
|
|
|
|
|
|
|
|
|
2015-05-04 18:05:13 +03:00
|
|
|
def generate_union(expr, meta):
|
2013-07-02 14:18:47 +04:00
|
|
|
|
2015-05-04 18:05:13 +03:00
|
|
|
name = expr[meta]
|
2013-07-02 14:18:47 +04:00
|
|
|
typeinfo = expr['data']
|
2013-07-03 17:58:57 +04:00
|
|
|
|
2013-07-02 14:18:47 +04:00
|
|
|
base = expr.get('base')
|
2013-07-03 17:58:57 +04:00
|
|
|
discriminator = expr.get('discriminator')
|
2013-07-02 14:18:47 +04:00
|
|
|
|
2014-03-07 05:08:56 +04:00
|
|
|
enum_define = discriminator_find_enum_define(expr)
|
|
|
|
if enum_define:
|
|
|
|
discriminator_type_name = enum_define['enum_name']
|
|
|
|
else:
|
|
|
|
discriminator_type_name = '%sKind' % (name)
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
ret = mcgen('''
|
|
|
|
struct %(name)s
|
|
|
|
{
|
2014-03-07 05:08:56 +04:00
|
|
|
%(discriminator_type_name)s kind;
|
2011-07-19 23:50:40 +04:00
|
|
|
union {
|
2012-03-06 21:55:56 +04:00
|
|
|
void *data;
|
2011-07-19 23:50:40 +04:00
|
|
|
''',
|
2014-03-07 05:08:56 +04:00
|
|
|
name=name,
|
|
|
|
discriminator_type_name=discriminator_type_name)
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
for key in typeinfo:
|
|
|
|
ret += mcgen('''
|
|
|
|
%(c_type)s %(c_name)s;
|
|
|
|
''',
|
|
|
|
c_type=c_type(typeinfo[key]),
|
2012-03-20 17:54:35 +04:00
|
|
|
c_name=c_fun(key))
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
ret += mcgen('''
|
|
|
|
};
|
2013-07-02 14:18:47 +04:00
|
|
|
''')
|
|
|
|
|
|
|
|
if base:
|
2015-05-04 18:05:07 +03:00
|
|
|
assert discriminator
|
|
|
|
base_fields = find_struct(base)['data'].copy()
|
|
|
|
del base_fields[discriminator]
|
2013-07-03 17:58:57 +04:00
|
|
|
ret += generate_struct_fields(base_fields)
|
|
|
|
else:
|
|
|
|
assert not discriminator
|
2013-07-02 14:18:47 +04:00
|
|
|
|
|
|
|
ret += mcgen('''
|
2011-07-19 23:50:40 +04:00
|
|
|
};
|
|
|
|
''')
|
2015-05-04 18:05:13 +03:00
|
|
|
if meta == 'alternate':
|
2013-07-08 18:14:21 +04:00
|
|
|
ret += mcgen('''
|
|
|
|
extern const int %(name)s_qtypes[];
|
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def generate_type_cleanup_decl(name):
|
|
|
|
ret = mcgen('''
|
|
|
|
void qapi_free_%(type)s(%(c_type)s obj);
|
|
|
|
''',
|
|
|
|
c_type=c_type(name),type=name)
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def generate_type_cleanup(name):
|
|
|
|
ret = mcgen('''
|
2013-05-11 02:46:00 +04:00
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
void qapi_free_%(type)s(%(c_type)s obj)
|
|
|
|
{
|
|
|
|
QapiDeallocVisitor *md;
|
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
if (!obj) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
md = qapi_dealloc_visitor_new();
|
|
|
|
v = qapi_dealloc_get_visitor(md);
|
|
|
|
visit_type_%(type)s(v, &obj, NULL, NULL);
|
|
|
|
qapi_dealloc_visitor_cleanup(md);
|
|
|
|
}
|
|
|
|
''',
|
|
|
|
c_type=c_type(name),type=name)
|
|
|
|
return ret
|
|
|
|
|
|
|
|
|
|
|
|
try:
|
2014-05-02 17:52:35 +04:00
|
|
|
opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
|
2013-05-11 02:46:00 +04:00
|
|
|
["source", "header", "builtins",
|
2014-05-02 17:52:35 +04:00
|
|
|
"prefix=", "input-file=", "output-dir="])
|
2011-07-19 23:50:40 +04:00
|
|
|
except getopt.GetoptError, err:
|
|
|
|
print str(err)
|
|
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
output_dir = ""
|
2014-05-02 17:52:35 +04:00
|
|
|
input_file = ""
|
2011-07-19 23:50:40 +04:00
|
|
|
prefix = ""
|
|
|
|
c_file = 'qapi-types.c'
|
|
|
|
h_file = 'qapi-types.h'
|
|
|
|
|
2011-12-27 18:02:16 +04:00
|
|
|
do_c = False
|
|
|
|
do_h = False
|
2013-05-11 02:46:00 +04:00
|
|
|
do_builtins = False
|
2011-12-27 18:02:16 +04:00
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
for o, a in opts:
|
|
|
|
if o in ("-p", "--prefix"):
|
|
|
|
prefix = a
|
2014-05-02 17:52:35 +04:00
|
|
|
elif o in ("-i", "--input-file"):
|
|
|
|
input_file = a
|
2011-07-19 23:50:40 +04:00
|
|
|
elif o in ("-o", "--output-dir"):
|
|
|
|
output_dir = a + "/"
|
2011-12-27 18:02:16 +04:00
|
|
|
elif o in ("-c", "--source"):
|
|
|
|
do_c = True
|
2011-12-28 14:26:58 +04:00
|
|
|
elif o in ("-h", "--header"):
|
|
|
|
do_h = True
|
2013-05-11 02:46:00 +04:00
|
|
|
elif o in ("-b", "--builtins"):
|
|
|
|
do_builtins = True
|
2011-12-27 18:02:16 +04:00
|
|
|
|
|
|
|
if not do_c and not do_h:
|
|
|
|
do_c = True
|
|
|
|
do_h = True
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
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
|
|
|
|
|
2011-12-27 18:02:16 +04:00
|
|
|
def maybe_open(really, name, opt):
|
|
|
|
if really:
|
|
|
|
return open(name, opt)
|
2011-12-28 14:26:58 +04:00
|
|
|
else:
|
|
|
|
import StringIO
|
|
|
|
return StringIO.StringIO()
|
2011-12-27 18:02:16 +04:00
|
|
|
|
|
|
|
fdef = maybe_open(do_c, c_file, 'w')
|
|
|
|
fdecl = maybe_open(do_h, h_file, 'w')
|
2011-07-19 23:50:40 +04:00
|
|
|
|
|
|
|
fdef.write(mcgen('''
|
|
|
|
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* deallocation functions for schema-defined QAPI types
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
* Michael Roth <mdroth@linux.vnet.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-12-17 21:19:43 +04:00
|
|
|
#include "qapi/dealloc-visitor.h"
|
2011-07-19 23:50:40 +04:00
|
|
|
#include "%(prefix)sqapi-types.h"
|
|
|
|
#include "%(prefix)sqapi-visit.h"
|
|
|
|
|
|
|
|
''', prefix=prefix))
|
|
|
|
|
|
|
|
fdecl.write(mcgen('''
|
|
|
|
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* schema-defined QAPI types
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef %(guard)s
|
|
|
|
#define %(guard)s
|
|
|
|
|
2012-08-20 03:39:37 +04:00
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdint.h>
|
2012-07-27 17:56:33 +04:00
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
''',
|
|
|
|
guard=guardname(h_file)))
|
|
|
|
|
2014-05-02 17:52:35 +04:00
|
|
|
exprs = parse_schema(input_file)
|
2011-12-13 00:29:33 +04:00
|
|
|
exprs = filter(lambda expr: not expr.has_key('gen'), exprs)
|
2011-07-19 23:50:40 +04:00
|
|
|
|
2013-05-11 02:46:00 +04:00
|
|
|
fdecl.write(guardstart("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
|
2015-05-04 18:05:00 +03:00
|
|
|
for typename in builtin_types.keys():
|
2013-05-11 02:46:00 +04:00
|
|
|
fdecl.write(generate_fwd_struct(typename, None, builtin_type=True))
|
|
|
|
fdecl.write(guardend("QAPI_TYPES_BUILTIN_STRUCT_DECL"))
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
for expr in exprs:
|
|
|
|
ret = "\n"
|
2015-05-04 18:05:25 +03:00
|
|
|
if expr.has_key('struct'):
|
|
|
|
ret += generate_fwd_struct(expr['struct'], expr['data'])
|
2011-07-19 23:50:40 +04:00
|
|
|
elif expr.has_key('enum'):
|
qapi: generate list struct and visit_list for enum
Currently, if we define an 'enum' and use it in one command's
data, list struct for enum could not be generated, but it's
used in qmp function.
For example: KeyCodesList could not be generated.
>>> qapi-schema.json:
{ 'enum': 'KeyCodes',
'data': [ 'shift', 'alt' ... ] }
{ 'command': 'sendkey',
'data': { 'keys': ['KeyCodes'], '*hold-time': 'int' } }
>>> qmp-command.h:
void qmp_sendkey(KeyCodesList * keys, bool has_hold_time, int64_t
hold_time, Error **errp);
This patch lets qapi generate list struct and visit_list for enum.
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2012-08-31 06:56:23 +04:00
|
|
|
ret += generate_enum(expr['enum'], expr['data']) + "\n"
|
|
|
|
ret += generate_fwd_enum_struct(expr['enum'], expr['data'])
|
2011-07-19 23:50:40 +04:00
|
|
|
fdef.write(generate_enum_lookup(expr['enum'], expr['data']))
|
|
|
|
elif expr.has_key('union'):
|
|
|
|
ret += generate_fwd_struct(expr['union'], expr['data']) + "\n"
|
2014-03-07 05:08:56 +04:00
|
|
|
enum_define = discriminator_find_enum_define(expr)
|
|
|
|
if not enum_define:
|
|
|
|
ret += generate_enum('%sKind' % expr['union'], expr['data'].keys())
|
|
|
|
fdef.write(generate_enum_lookup('%sKind' % expr['union'],
|
|
|
|
expr['data'].keys()))
|
2015-05-04 18:05:13 +03:00
|
|
|
elif expr.has_key('alternate'):
|
|
|
|
ret += generate_fwd_struct(expr['alternate'], expr['data']) + "\n"
|
|
|
|
ret += generate_enum('%sKind' % expr['alternate'], expr['data'].keys())
|
|
|
|
fdef.write(generate_enum_lookup('%sKind' % expr['alternate'],
|
|
|
|
expr['data'].keys()))
|
|
|
|
fdef.write(generate_alternate_qtypes(expr))
|
2011-07-19 23:50:40 +04:00
|
|
|
else:
|
|
|
|
continue
|
|
|
|
fdecl.write(ret)
|
|
|
|
|
2013-05-11 02:46:00 +04:00
|
|
|
# to avoid header dependency hell, we always generate declarations
|
|
|
|
# for built-in types in our header files and simply guard them
|
|
|
|
fdecl.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
|
2015-05-04 18:05:00 +03:00
|
|
|
for typename in builtin_types.keys():
|
2013-05-11 02:46:00 +04:00
|
|
|
fdecl.write(generate_type_cleanup_decl(typename + "List"))
|
|
|
|
fdecl.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DECL"))
|
|
|
|
|
|
|
|
# ...this doesn't work for cases where we link in multiple objects that
|
|
|
|
# have the functions defined, so we use -b option to provide control
|
|
|
|
# over these cases
|
|
|
|
if do_builtins:
|
|
|
|
fdef.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
|
2015-05-04 18:05:00 +03:00
|
|
|
for typename in builtin_types.keys():
|
2013-05-11 02:46:00 +04:00
|
|
|
fdef.write(generate_type_cleanup(typename + "List"))
|
|
|
|
fdef.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DEF"))
|
|
|
|
|
2011-07-19 23:50:40 +04:00
|
|
|
for expr in exprs:
|
|
|
|
ret = "\n"
|
2015-05-04 18:05:25 +03:00
|
|
|
if expr.has_key('struct'):
|
2013-09-18 19:22:02 +04:00
|
|
|
ret += generate_struct(expr) + "\n"
|
2015-05-04 18:05:25 +03:00
|
|
|
ret += generate_type_cleanup_decl(expr['struct'] + "List")
|
|
|
|
fdef.write(generate_type_cleanup(expr['struct'] + "List") + "\n")
|
|
|
|
ret += generate_type_cleanup_decl(expr['struct'])
|
|
|
|
fdef.write(generate_type_cleanup(expr['struct']) + "\n")
|
2011-07-19 23:50:40 +04:00
|
|
|
elif expr.has_key('union'):
|
2015-05-04 18:05:13 +03:00
|
|
|
ret += generate_union(expr, 'union')
|
2012-03-06 21:55:56 +04:00
|
|
|
ret += generate_type_cleanup_decl(expr['union'] + "List")
|
|
|
|
fdef.write(generate_type_cleanup(expr['union'] + "List") + "\n")
|
|
|
|
ret += generate_type_cleanup_decl(expr['union'])
|
|
|
|
fdef.write(generate_type_cleanup(expr['union']) + "\n")
|
2015-05-04 18:05:13 +03:00
|
|
|
elif expr.has_key('alternate'):
|
|
|
|
ret += generate_union(expr, 'alternate')
|
|
|
|
ret += generate_type_cleanup_decl(expr['alternate'] + "List")
|
|
|
|
fdef.write(generate_type_cleanup(expr['alternate'] + "List") + "\n")
|
|
|
|
ret += generate_type_cleanup_decl(expr['alternate'])
|
|
|
|
fdef.write(generate_type_cleanup(expr['alternate']) + "\n")
|
qapi: generate list struct and visit_list for enum
Currently, if we define an 'enum' and use it in one command's
data, list struct for enum could not be generated, but it's
used in qmp function.
For example: KeyCodesList could not be generated.
>>> qapi-schema.json:
{ 'enum': 'KeyCodes',
'data': [ 'shift', 'alt' ... ] }
{ 'command': 'sendkey',
'data': { 'keys': ['KeyCodes'], '*hold-time': 'int' } }
>>> qmp-command.h:
void qmp_sendkey(KeyCodesList * keys, bool has_hold_time, int64_t
hold_time, Error **errp);
This patch lets qapi generate list struct and visit_list for enum.
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2012-08-31 06:56:23 +04:00
|
|
|
elif expr.has_key('enum'):
|
|
|
|
ret += generate_type_cleanup_decl(expr['enum'] + "List")
|
|
|
|
fdef.write(generate_type_cleanup(expr['enum'] + "List") + "\n")
|
2011-07-19 23:50:40 +04:00
|
|
|
else:
|
|
|
|
continue
|
|
|
|
fdecl.write(ret)
|
|
|
|
|
|
|
|
fdecl.write('''
|
|
|
|
#endif
|
|
|
|
''')
|
|
|
|
|
|
|
|
fdecl.flush()
|
|
|
|
fdecl.close()
|
2011-09-02 21:34:46 +04:00
|
|
|
|
|
|
|
fdef.flush()
|
|
|
|
fdef.close()
|