2011-07-19 21:50:41 +02:00
|
|
|
#
|
|
|
|
# QAPI visitor generator
|
|
|
|
#
|
|
|
|
# Copyright IBM, Corp. 2011
|
2015-04-10 23:07:59 +02:00
|
|
|
# Copyright (C) 2014-2015 Red Hat, Inc.
|
2011-07-19 21:50:41 +02:00
|
|
|
#
|
|
|
|
# Authors:
|
|
|
|
# Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
# Michael Roth <mdroth@linux.vnet.ibm.com>
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
# Markus Armbruster <armbru@redhat.com>
|
2011-07-19 21:50:41 +02:00
|
|
|
#
|
2014-03-01 08:40:34 +01: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 21:50:41 +02:00
|
|
|
|
|
|
|
from ordereddict import OrderedDict
|
|
|
|
from qapi import *
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
import re
|
2011-07-19 21:50:41 +02:00
|
|
|
import sys
|
|
|
|
import os
|
|
|
|
import getopt
|
|
|
|
import errno
|
|
|
|
|
2014-05-07 09:53:50 +02:00
|
|
|
implicit_structs = []
|
|
|
|
|
|
|
|
def generate_visit_implicit_struct(type):
|
|
|
|
global implicit_structs
|
|
|
|
if type in implicit_structs:
|
|
|
|
return ''
|
|
|
|
implicit_structs.append(type)
|
|
|
|
return mcgen('''
|
|
|
|
|
|
|
|
static void visit_type_implicit_%(c_type)s(Visitor *m, %(c_type)s **obj, Error **errp)
|
|
|
|
{
|
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
visit_start_implicit_struct(m, (void **)obj, sizeof(%(c_type)s), &err);
|
|
|
|
if (!err) {
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
visit_type_%(c_type)s_fields(m, obj, errp);
|
2014-05-07 09:53:50 +02:00
|
|
|
visit_end_implicit_struct(m, &err);
|
|
|
|
}
|
|
|
|
error_propagate(errp, err);
|
|
|
|
}
|
|
|
|
''',
|
|
|
|
c_type=type_name(type))
|
|
|
|
|
2015-05-04 17:05:34 +02:00
|
|
|
def generate_visit_struct_fields(name, members, base = None):
|
2013-07-03 15:58:57 +02:00
|
|
|
substructs = []
|
2013-07-02 16:18:35 +02:00
|
|
|
ret = ''
|
2013-07-03 15:58:57 +02:00
|
|
|
|
2014-05-07 09:53:50 +02:00
|
|
|
if base:
|
|
|
|
ret += generate_visit_implicit_struct(base)
|
|
|
|
|
2013-07-03 15:58:57 +02:00
|
|
|
ret += mcgen('''
|
|
|
|
|
2015-05-04 17:05:34 +02:00
|
|
|
static void visit_type_%(name)s_fields(Visitor *m, %(name)s **obj, Error **errp)
|
2013-07-03 15:58:57 +02:00
|
|
|
{
|
|
|
|
Error *err = NULL;
|
|
|
|
''',
|
2015-05-14 14:50:57 +02:00
|
|
|
name=c_name(name))
|
2013-07-03 15:58:57 +02:00
|
|
|
push_indent()
|
2012-07-17 16:17:04 +02:00
|
|
|
|
2013-09-19 11:56:36 +02:00
|
|
|
if base:
|
|
|
|
ret += mcgen('''
|
2015-05-04 17:05:34 +02:00
|
|
|
visit_type_implicit_%(type)s(m, &(*obj)->%(c_name)s, &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
2013-09-19 11:56:36 +02:00
|
|
|
''',
|
2015-05-14 14:50:48 +02:00
|
|
|
type=type_name(base), c_name=c_name('base'))
|
2013-09-19 11:56:36 +02:00
|
|
|
|
2015-05-04 17:05:33 +02:00
|
|
|
for argname, argentry, optional in parse_args(members):
|
2011-07-19 21:50:41 +02:00
|
|
|
if optional:
|
|
|
|
ret += mcgen('''
|
2015-05-04 17:05:34 +02:00
|
|
|
visit_optional(m, &(*obj)->has_%(c_name)s, "%(name)s", &err);
|
|
|
|
if (!err && (*obj)->has_%(c_name)s) {
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
2015-05-14 14:50:48 +02:00
|
|
|
c_name=c_name(argname), name=argname)
|
2011-07-19 21:50:41 +02:00
|
|
|
push_indent()
|
|
|
|
|
2015-05-04 17:05:33 +02:00
|
|
|
ret += mcgen('''
|
2015-05-04 17:05:34 +02:00
|
|
|
visit_type_%(type)s(m, &(*obj)->%(c_name)s, "%(name)s", &err);
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
2015-05-14 14:50:48 +02:00
|
|
|
type=type_name(argentry), c_name=c_name(argname),
|
2015-05-04 17:05:33 +02:00
|
|
|
name=argname)
|
2011-07-19 21:50:41 +02:00
|
|
|
|
|
|
|
if optional:
|
|
|
|
pop_indent()
|
|
|
|
ret += mcgen('''
|
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
''')
|
|
|
|
ret += mcgen('''
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
2012-07-17 16:17:04 +02:00
|
|
|
''')
|
|
|
|
|
2013-07-03 15:58:57 +02:00
|
|
|
pop_indent()
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if re.search('^ *goto out\\;', ret, re.MULTILINE):
|
|
|
|
ret += mcgen('''
|
2013-07-03 15:58:57 +02:00
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
out:
|
|
|
|
''')
|
|
|
|
ret += mcgen('''
|
2013-07-03 15:58:57 +02:00
|
|
|
error_propagate(errp, err);
|
|
|
|
}
|
|
|
|
''')
|
2013-07-02 16:18:35 +02:00
|
|
|
return ret
|
|
|
|
|
|
|
|
|
2015-05-04 17:05:34 +02:00
|
|
|
def generate_visit_struct_body(name, members):
|
2013-07-02 16:18:35 +02:00
|
|
|
ret = mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
|
2015-05-14 14:50:57 +02:00
|
|
|
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (!err) {
|
|
|
|
if (*obj) {
|
2015-05-14 14:50:57 +02:00
|
|
|
visit_type_%(c_name)s_fields(m, obj, errp);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
}
|
|
|
|
visit_end_struct(m, &err);
|
2013-07-03 15:58:57 +02:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
error_propagate(errp, err);
|
2013-07-03 15:58:57 +02:00
|
|
|
''',
|
2015-05-14 14:50:57 +02:00
|
|
|
name=name, c_name=c_name(name))
|
2012-07-17 16:17:04 +02:00
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
return ret
|
|
|
|
|
2013-09-18 17:22:02 +02:00
|
|
|
def generate_visit_struct(expr):
|
|
|
|
|
2015-05-04 17:05:25 +02:00
|
|
|
name = expr['struct']
|
2013-09-18 17:22:02 +02:00
|
|
|
members = expr['data']
|
2013-09-19 11:56:36 +02:00
|
|
|
base = expr.get('base')
|
2013-09-18 17:22:02 +02:00
|
|
|
|
2015-05-04 17:05:34 +02:00
|
|
|
ret = generate_visit_struct_fields(name, members, base)
|
2013-07-03 15:58:57 +02:00
|
|
|
|
|
|
|
ret += mcgen('''
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
2011-07-19 21:50:41 +02:00
|
|
|
{
|
|
|
|
''',
|
2015-05-14 14:50:57 +02:00
|
|
|
name=c_name(name))
|
2012-07-17 16:17:04 +02:00
|
|
|
|
2015-05-04 17:05:34 +02:00
|
|
|
ret += generate_visit_struct_body(name, members)
|
2011-07-19 21:50:41 +02:00
|
|
|
|
|
|
|
ret += mcgen('''
|
|
|
|
}
|
|
|
|
''')
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def generate_visit_list(name, members):
|
|
|
|
return mcgen('''
|
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp)
|
2011-07-19 21:50:41 +02:00
|
|
|
{
|
2012-07-17 16:17:04 +02:00
|
|
|
Error *err = NULL;
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
GenericList *i, **prev;
|
2011-07-19 21:50:41 +02:00
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
visit_start_list(m, name, &err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (prev = (GenericList **)obj;
|
|
|
|
!err && (i = visit_next_list(m, prev, &err)) != NULL;
|
|
|
|
prev = &i) {
|
|
|
|
%(name)sList *native_i = (%(name)sList *)i;
|
|
|
|
visit_type_%(name)s(m, &native_i->value, NULL, &err);
|
2011-07-19 21:50:41 +02:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
|
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
|
|
|
visit_end_list(m, &err);
|
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
2011-07-19 21:50:41 +02:00
|
|
|
}
|
|
|
|
''',
|
2015-05-14 14:50:56 +02:00
|
|
|
name=type_name(name))
|
2011-07-19 21:50:41 +02:00
|
|
|
|
|
|
|
def generate_visit_enum(name, members):
|
|
|
|
return mcgen('''
|
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp)
|
2011-07-19 21:50:41 +02:00
|
|
|
{
|
|
|
|
visit_type_enum(m, (int *)obj, %(name)s_lookup, "%(name)s", name, errp);
|
|
|
|
}
|
|
|
|
''',
|
2015-05-14 14:50:56 +02:00
|
|
|
name=c_name(name))
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2015-05-04 17:05:10 +02:00
|
|
|
def generate_visit_alternate(name, members):
|
2013-07-08 16:14:21 +02:00
|
|
|
ret = mcgen('''
|
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
2013-07-08 16:14:21 +02:00
|
|
|
{
|
|
|
|
Error *err = NULL;
|
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err);
|
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
|
|
|
switch ((*obj)->kind) {
|
2013-07-08 16:14:21 +02:00
|
|
|
''',
|
2015-05-14 14:51:00 +02:00
|
|
|
name=c_name(name))
|
2013-07-08 16:14:21 +02:00
|
|
|
|
2015-05-04 17:05:13 +02:00
|
|
|
# For alternate, always use the default enum type automatically generated
|
2015-05-14 14:51:00 +02:00
|
|
|
# as name + 'Kind'
|
|
|
|
disc_type = c_name(name) + 'Kind'
|
2014-03-05 03:44:36 +01:00
|
|
|
|
2013-07-08 16:14:21 +02:00
|
|
|
for key in members:
|
2015-05-04 17:05:00 +02:00
|
|
|
assert (members[key] in builtin_types.keys()
|
2013-07-08 16:14:21 +02:00
|
|
|
or find_struct(members[key])
|
2014-08-20 19:59:34 +02:00
|
|
|
or find_union(members[key])
|
2015-05-04 17:05:13 +02:00
|
|
|
or find_enum(members[key])), "Invalid alternate member"
|
2013-07-08 16:14:21 +02:00
|
|
|
|
2015-05-14 14:50:50 +02:00
|
|
|
enum_full_value = c_enum_const(disc_type, key)
|
2013-07-08 16:14:21 +02:00
|
|
|
ret += mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
case %(enum_full_value)s:
|
|
|
|
visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err);
|
|
|
|
break;
|
2013-07-08 16:14:21 +02:00
|
|
|
''',
|
2014-03-05 03:44:36 +01:00
|
|
|
enum_full_value = enum_full_value,
|
2013-07-08 16:14:21 +02:00
|
|
|
c_type = type_name(members[key]),
|
2015-05-14 14:50:48 +02:00
|
|
|
c_name = c_name(key))
|
2013-07-08 16:14:21 +02:00
|
|
|
|
|
|
|
ret += mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
default:
|
|
|
|
abort();
|
2013-07-08 16:14:21 +02:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
out_end:
|
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
|
|
|
visit_end_implicit_struct(m, &err);
|
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
2013-07-08 16:14:21 +02:00
|
|
|
}
|
|
|
|
''')
|
|
|
|
|
|
|
|
return ret
|
|
|
|
|
|
|
|
|
2013-07-02 16:20:04 +02:00
|
|
|
def generate_visit_union(expr):
|
|
|
|
|
|
|
|
name = expr['union']
|
|
|
|
members = expr['data']
|
|
|
|
|
|
|
|
base = expr.get('base')
|
2013-07-03 15:58:57 +02:00
|
|
|
discriminator = expr.get('discriminator')
|
2013-07-02 16:20:04 +02:00
|
|
|
|
2014-03-07 02:08:56 +01:00
|
|
|
enum_define = discriminator_find_enum_define(expr)
|
|
|
|
if enum_define:
|
|
|
|
# Use the enum type as discriminator
|
|
|
|
ret = ""
|
2015-05-14 14:50:59 +02:00
|
|
|
disc_type = c_name(enum_define['enum_name'])
|
2014-03-07 02:08:56 +01:00
|
|
|
else:
|
2015-05-04 17:05:07 +02:00
|
|
|
# There will always be a discriminator in the C switch code, by default
|
2015-05-14 14:50:58 +02:00
|
|
|
# it is an enum type generated silently
|
|
|
|
ret = generate_visit_enum(name + 'Kind', members.keys())
|
|
|
|
disc_type = c_name(name) + 'Kind'
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2013-07-03 15:58:57 +02:00
|
|
|
if base:
|
2015-05-04 17:05:07 +02:00
|
|
|
assert discriminator
|
|
|
|
base_fields = find_struct(base)['data'].copy()
|
|
|
|
del base_fields[discriminator]
|
2015-05-04 17:05:34 +02:00
|
|
|
ret += generate_visit_struct_fields(name, base_fields)
|
2013-07-03 15:58:57 +02:00
|
|
|
|
2014-05-07 09:53:50 +02:00
|
|
|
if discriminator:
|
|
|
|
for key in members:
|
|
|
|
ret += generate_visit_implicit_struct(members[key])
|
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
ret += mcgen('''
|
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp)
|
2011-07-19 21:50:41 +02:00
|
|
|
{
|
2012-03-06 18:55:56 +01:00
|
|
|
Error *err = NULL;
|
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (*obj) {
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
2015-05-14 14:50:58 +02:00
|
|
|
name=c_name(name))
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2013-07-02 16:20:04 +02:00
|
|
|
if base:
|
2013-07-03 15:58:57 +02:00
|
|
|
ret += mcgen('''
|
2014-05-07 09:53:47 +02:00
|
|
|
visit_type_%(name)s_fields(m, obj, &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_obj;
|
|
|
|
}
|
2013-07-03 15:58:57 +02:00
|
|
|
''',
|
2015-05-14 14:50:59 +02:00
|
|
|
name=c_name(name))
|
2013-07-02 16:20:04 +02:00
|
|
|
|
2013-10-31 21:26:01 +01:00
|
|
|
if not discriminator:
|
2014-03-07 02:08:56 +01:00
|
|
|
disc_key = "type"
|
2013-10-31 21:26:01 +01:00
|
|
|
else:
|
2014-03-07 02:08:56 +01:00
|
|
|
disc_key = discriminator
|
2013-07-02 16:20:04 +02:00
|
|
|
ret += mcgen('''
|
2014-03-07 02:08:56 +01:00
|
|
|
visit_type_%(disc_type)s(m, &(*obj)->kind, "%(disc_key)s", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_obj;
|
|
|
|
}
|
2014-09-18 22:36:40 +02:00
|
|
|
if (!visit_start_union(m, !!(*obj)->data, &err) || err) {
|
|
|
|
goto out_obj;
|
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
switch ((*obj)->kind) {
|
2013-07-02 16:20:04 +02:00
|
|
|
''',
|
2014-03-07 02:08:56 +01:00
|
|
|
disc_type = disc_type,
|
|
|
|
disc_key = disc_key)
|
2013-07-02 16:20:04 +02:00
|
|
|
|
2012-03-06 18:55:56 +01:00
|
|
|
for key in members:
|
2013-07-03 15:58:57 +02:00
|
|
|
if not discriminator:
|
|
|
|
fmt = 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);'
|
|
|
|
else:
|
2014-05-07 09:53:50 +02:00
|
|
|
fmt = 'visit_type_implicit_%(c_type)s(m, &(*obj)->%(c_name)s, &err);'
|
2013-07-03 15:58:57 +02:00
|
|
|
|
2015-05-14 14:50:50 +02:00
|
|
|
enum_full_value = c_enum_const(disc_type, key)
|
2012-03-06 18:55:56 +01:00
|
|
|
ret += mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
case %(enum_full_value)s:
|
|
|
|
''' + fmt + '''
|
|
|
|
break;
|
2012-03-06 18:55:56 +01:00
|
|
|
''',
|
2014-03-05 03:44:36 +01:00
|
|
|
enum_full_value = enum_full_value,
|
2013-05-11 00:46:01 +02:00
|
|
|
c_type=type_name(members[key]),
|
2015-05-14 14:50:48 +02:00
|
|
|
c_name=c_name(key))
|
2012-03-06 18:55:56 +01:00
|
|
|
|
|
|
|
ret += mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
default:
|
|
|
|
abort();
|
2012-07-17 16:17:04 +02:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
out_obj:
|
2012-07-17 16:17:04 +02:00
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
2014-09-18 22:36:40 +02:00
|
|
|
visit_end_union(m, !!(*obj)->data, &err);
|
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
2014-05-07 09:53:47 +02:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
visit_end_struct(m, &err);
|
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
2012-03-06 18:55:56 +01:00
|
|
|
}
|
|
|
|
''')
|
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
return ret
|
|
|
|
|
2015-04-10 23:07:59 +02:00
|
|
|
def generate_declaration(name, members, builtin_type=False):
|
2013-05-11 00:46:02 +02:00
|
|
|
ret = ""
|
|
|
|
if not builtin_type:
|
2015-05-14 14:50:57 +02:00
|
|
|
name = c_name(name)
|
2013-05-11 00:46:02 +02:00
|
|
|
ret += mcgen('''
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s **obj, const char *name, Error **errp);
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
2015-04-10 23:07:59 +02:00
|
|
|
name=name)
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2015-04-10 23:07:59 +02:00
|
|
|
ret += mcgen('''
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
|
|
|
name=name)
|
|
|
|
|
|
|
|
return ret
|
|
|
|
|
2015-04-10 23:07:59 +02:00
|
|
|
def generate_enum_declaration(name, members):
|
|
|
|
ret = mcgen('''
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)sList(Visitor *m, %(name)sList **obj, const char *name, Error **errp);
|
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 04:56:23 +02:00
|
|
|
''',
|
2015-05-14 14:50:56 +02:00
|
|
|
name=c_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 04:56:23 +02:00
|
|
|
|
|
|
|
return ret
|
|
|
|
|
2015-04-10 23:07:59 +02:00
|
|
|
def generate_decl_enum(name, members):
|
2011-07-19 21:50:41 +02:00
|
|
|
return mcgen('''
|
|
|
|
|
2014-06-10 13:25:51 +02:00
|
|
|
void visit_type_%(name)s(Visitor *m, %(name)s *obj, const char *name, Error **errp);
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
2015-05-14 14:50:56 +02:00
|
|
|
name=c_name(name))
|
2011-07-19 21:50:41 +02:00
|
|
|
|
|
|
|
try:
|
2014-05-02 15:52:35 +02:00
|
|
|
opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
|
2013-05-11 00:46:02 +02:00
|
|
|
["source", "header", "builtins", "prefix=",
|
2014-05-02 15:52:35 +02:00
|
|
|
"input-file=", "output-dir="])
|
2011-07-19 21:50:41 +02:00
|
|
|
except getopt.GetoptError, err:
|
|
|
|
print str(err)
|
|
|
|
sys.exit(1)
|
|
|
|
|
2014-05-02 15:52:35 +02:00
|
|
|
input_file = ""
|
2011-07-19 21:50:41 +02:00
|
|
|
output_dir = ""
|
|
|
|
prefix = ""
|
|
|
|
c_file = 'qapi-visit.c'
|
|
|
|
h_file = 'qapi-visit.h'
|
|
|
|
|
2011-12-27 15:02:16 +01:00
|
|
|
do_c = False
|
|
|
|
do_h = False
|
2013-05-11 00:46:02 +02:00
|
|
|
do_builtins = False
|
2011-12-27 15:02:16 +01:00
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
for o, a in opts:
|
|
|
|
if o in ("-p", "--prefix"):
|
|
|
|
prefix = a
|
2014-05-02 15:52:35 +02:00
|
|
|
elif o in ("-i", "--input-file"):
|
|
|
|
input_file = a
|
2011-07-19 21:50:41 +02:00
|
|
|
elif o in ("-o", "--output-dir"):
|
|
|
|
output_dir = a + "/"
|
2011-12-27 15:02:16 +01:00
|
|
|
elif o in ("-c", "--source"):
|
|
|
|
do_c = True
|
2011-12-28 11:26:58 +01:00
|
|
|
elif o in ("-h", "--header"):
|
|
|
|
do_h = True
|
2013-05-11 00:46:02 +02:00
|
|
|
elif o in ("-b", "--builtins"):
|
|
|
|
do_builtins = True
|
2011-12-27 15:02:16 +01:00
|
|
|
|
|
|
|
if not do_c and not do_h:
|
|
|
|
do_c = True
|
|
|
|
do_h = True
|
2011-07-19 21:50:41 +02: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 15:02:16 +01:00
|
|
|
def maybe_open(really, name, opt):
|
|
|
|
if really:
|
|
|
|
return open(name, opt)
|
2011-12-28 11:26:58 +01:00
|
|
|
else:
|
|
|
|
import StringIO
|
|
|
|
return StringIO.StringIO()
|
2011-12-27 15:02:16 +01:00
|
|
|
|
|
|
|
fdef = maybe_open(do_c, c_file, 'w')
|
|
|
|
fdecl = maybe_open(do_h, h_file, 'w')
|
2011-07-19 21:50:41 +02:00
|
|
|
|
|
|
|
fdef.write(mcgen('''
|
|
|
|
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* schema-defined QAPI visitor functions
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-12-06 11:22:34 +01:00
|
|
|
#include "qemu-common.h"
|
2011-07-19 21:50:41 +02:00
|
|
|
#include "%(header)s"
|
|
|
|
''',
|
|
|
|
header=basename(h_file)))
|
|
|
|
|
|
|
|
fdecl.write(mcgen('''
|
|
|
|
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
|
|
|
|
|
|
|
|
/*
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
* schema-defined QAPI visitor functions
|
2011-07-19 21:50:41 +02:00
|
|
|
*
|
|
|
|
* 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-12-17 18:19:43 +01:00
|
|
|
#include "qapi/visitor.h"
|
2011-07-19 21:50:41 +02:00
|
|
|
#include "%(prefix)sqapi-types.h"
|
2013-05-11 00:46:02 +02:00
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
''',
|
|
|
|
prefix=prefix, guard=guardname(h_file)))
|
|
|
|
|
2014-05-02 15:52:35 +02:00
|
|
|
exprs = parse_schema(input_file)
|
2011-07-19 21:50:41 +02:00
|
|
|
|
2013-05-11 00:46:02 +02: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_VISIT_BUILTIN_VISITOR_DECL"))
|
2015-05-04 17:05:00 +02:00
|
|
|
for typename in builtin_types.keys():
|
2015-04-10 23:07:59 +02:00
|
|
|
fdecl.write(generate_declaration(typename, None, builtin_type=True))
|
2013-05-11 00:46:02 +02:00
|
|
|
fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_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:
|
2015-05-04 17:05:00 +02:00
|
|
|
for typename in builtin_types.keys():
|
2013-05-11 00:46:02 +02:00
|
|
|
fdef.write(generate_visit_list(typename, None))
|
|
|
|
|
2011-07-19 21:50:41 +02:00
|
|
|
for expr in exprs:
|
2015-05-04 17:05:25 +02:00
|
|
|
if expr.has_key('struct'):
|
2013-09-18 17:22:02 +02:00
|
|
|
ret = generate_visit_struct(expr)
|
2015-05-04 17:05:25 +02:00
|
|
|
ret += generate_visit_list(expr['struct'], expr['data'])
|
2011-07-19 21:50:41 +02:00
|
|
|
fdef.write(ret)
|
|
|
|
|
2015-05-04 17:05:25 +02:00
|
|
|
ret = generate_declaration(expr['struct'], expr['data'])
|
2011-07-19 21:50:41 +02:00
|
|
|
fdecl.write(ret)
|
|
|
|
elif expr.has_key('union'):
|
2013-07-02 16:20:04 +02:00
|
|
|
ret = generate_visit_union(expr)
|
2012-03-06 18:55:56 +01:00
|
|
|
ret += generate_visit_list(expr['union'], expr['data'])
|
2011-07-19 21:50:41 +02:00
|
|
|
fdef.write(ret)
|
|
|
|
|
2014-03-07 02:08:56 +01:00
|
|
|
enum_define = discriminator_find_enum_define(expr)
|
|
|
|
ret = ""
|
|
|
|
if not enum_define:
|
|
|
|
ret = generate_decl_enum('%sKind' % expr['union'],
|
|
|
|
expr['data'].keys())
|
2011-07-19 21:50:41 +02:00
|
|
|
ret += generate_declaration(expr['union'], expr['data'])
|
|
|
|
fdecl.write(ret)
|
2015-05-04 17:05:13 +02:00
|
|
|
elif expr.has_key('alternate'):
|
|
|
|
ret = generate_visit_alternate(expr['alternate'], expr['data'])
|
|
|
|
ret += generate_visit_list(expr['alternate'], expr['data'])
|
|
|
|
fdef.write(ret)
|
|
|
|
|
|
|
|
ret = generate_decl_enum('%sKind' % expr['alternate'],
|
|
|
|
expr['data'].keys())
|
|
|
|
ret += generate_declaration(expr['alternate'], expr['data'])
|
|
|
|
fdecl.write(ret)
|
2011-07-19 21:50:41 +02: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 04:56:23 +02:00
|
|
|
ret = generate_visit_list(expr['enum'], expr['data'])
|
|
|
|
ret += generate_visit_enum(expr['enum'], expr['data'])
|
2011-07-19 21:50:41 +02:00
|
|
|
fdef.write(ret)
|
|
|
|
|
|
|
|
ret = generate_decl_enum(expr['enum'], expr['data'])
|
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 04:56:23 +02:00
|
|
|
ret += generate_enum_declaration(expr['enum'], expr['data'])
|
2011-07-19 21:50:41 +02:00
|
|
|
fdecl.write(ret)
|
|
|
|
|
|
|
|
fdecl.write('''
|
|
|
|
#endif
|
|
|
|
''')
|
|
|
|
|
|
|
|
fdecl.flush()
|
|
|
|
fdecl.close()
|
|
|
|
|
|
|
|
fdef.flush()
|
|
|
|
fdef.close()
|