2011-11-15 01:05:29 +04:00
|
|
|
/*
|
2016-09-30 17:45:27 +03:00
|
|
|
* QObject Output Visitor unit-tests.
|
2011-11-15 01:05:29 +04:00
|
|
|
*
|
2016-02-18 09:48:18 +03:00
|
|
|
* Copyright (C) 2011-2016 Red Hat Inc.
|
2011-11-15 01:05:29 +04:00
|
|
|
*
|
|
|
|
|
* Authors:
|
|
|
|
|
* Luiz Capitulino <lcapitulino@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-02-08 21:08:51 +03:00
|
|
|
#include "qemu/osdep.h"
|
2011-11-15 01:05:29 +04:00
|
|
|
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2016-09-30 17:45:27 +03:00
|
|
|
#include "qapi/qobject-output-visitor.h"
|
2011-11-15 01:05:29 +04:00
|
|
|
#include "test-qapi-visit.h"
|
2018-02-01 14:18:35 +03:00
|
|
|
#include "qapi/qmp/qbool.h"
|
2018-02-01 14:18:39 +03:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2018-02-01 14:18:38 +03:00
|
|
|
#include "qapi/qmp/qlist.h"
|
2018-02-01 14:18:36 +03:00
|
|
|
#include "qapi/qmp/qnull.h"
|
|
|
|
|
#include "qapi/qmp/qnum.h"
|
2018-02-01 14:18:40 +03:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2011-11-15 01:05:29 +04:00
|
|
|
|
|
|
|
|
typedef struct TestOutputVisitorData {
|
|
|
|
|
Visitor *ov;
|
2016-06-09 19:48:42 +03:00
|
|
|
QObject *obj;
|
2011-11-15 01:05:29 +04:00
|
|
|
} TestOutputVisitorData;
|
|
|
|
|
|
|
|
|
|
static void visitor_output_setup(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
2016-09-30 17:45:28 +03:00
|
|
|
data->ov = qobject_output_visitor_new(&data->obj);
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 19:48:43 +03:00
|
|
|
g_assert(data->ov);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void visitor_output_teardown(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
2016-06-09 19:48:40 +03:00
|
|
|
visit_free(data->ov);
|
2011-11-15 01:05:29 +04:00
|
|
|
data->ov = NULL;
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(data->obj);
|
2016-06-09 19:48:42 +03:00
|
|
|
data->obj = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static QObject *visitor_get(TestOutputVisitorData *data)
|
|
|
|
|
{
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 19:48:43 +03:00
|
|
|
visit_complete(data->ov, &data->obj);
|
2016-06-09 19:48:42 +03:00
|
|
|
g_assert(data->obj);
|
|
|
|
|
return data->obj;
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
2016-05-10 07:20:06 +03:00
|
|
|
static void visitor_reset(TestOutputVisitorData *data)
|
|
|
|
|
{
|
|
|
|
|
visitor_output_teardown(data, NULL);
|
|
|
|
|
visitor_output_setup(data, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-15 01:05:29 +04:00
|
|
|
static void test_visitor_out_int(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
int64_t value = -42;
|
2017-06-07 19:35:58 +03:00
|
|
|
int64_t val;
|
|
|
|
|
QNum *qnum;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_int(data->ov, NULL, &value, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qnum = qobject_to(QNum, visitor_get(data));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum);
|
|
|
|
|
g_assert(qnum_get_try_int(qnum, &val));
|
|
|
|
|
g_assert_cmpint(val, ==, value);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_bool(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
bool value = true;
|
2017-02-17 23:38:23 +03:00
|
|
|
QBool *qbool;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_bool(data->ov, NULL, &value, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qbool = qobject_to(QBool, visitor_get(data));
|
2017-02-17 23:38:23 +03:00
|
|
|
g_assert(qbool);
|
|
|
|
|
g_assert(qbool_get_bool(qbool) == value);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_number(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
double value = 3.14;
|
2017-06-07 19:35:58 +03:00
|
|
|
QNum *qnum;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_number(data->ov, NULL, &value, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qnum = qobject_to(QNum, visitor_get(data));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum);
|
|
|
|
|
g_assert(qnum_get_double(qnum) == value);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_string(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
char *string = (char *) "Q E M U";
|
2017-02-17 23:38:20 +03:00
|
|
|
QString *qstr;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_str(data->ov, NULL, &string, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qstr = qobject_to(QString, visitor_get(data));
|
2017-02-17 23:38:20 +03:00
|
|
|
g_assert(qstr);
|
|
|
|
|
g_assert_cmpstr(qstring_get_str(qstr), ==, string);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_no_string(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
char *string = NULL;
|
2017-02-17 23:38:20 +03:00
|
|
|
QString *qstr;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
|
|
|
|
/* A null string should return "" */
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_str(data->ov, NULL, &string, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qstr = qobject_to(QString, visitor_get(data));
|
2017-02-17 23:38:20 +03:00
|
|
|
g_assert(qstr);
|
|
|
|
|
g_assert_cmpstr(qstring_get_str(qstr), ==, "");
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_enum(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
EnumOne i;
|
2017-02-17 23:38:20 +03:00
|
|
|
QString *qstr;
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Don't let implicit enum MAX member collide
Now that we guarantee the user doesn't have any enum values
beginning with a single underscore, we can use that for our
own purposes. Renaming ENUM_MAX to ENUM__MAX makes it obvious
that the sentinel is generated.
This patch was mostly generated by applying a temporary patch:
|diff --git a/scripts/qapi.py b/scripts/qapi.py
|index e6d014b..b862ec9 100644
|--- a/scripts/qapi.py
|+++ b/scripts/qapi.py
|@@ -1570,6 +1570,7 @@ const char *const %(c_name)s_lookup[] = {
| max_index = c_enum_const(name, 'MAX', prefix)
| ret += mcgen('''
| [%(max_index)s] = NULL,
|+// %(max_index)s
| };
| ''',
| max_index=max_index)
then running:
$ cat qapi-{types,event}.c tests/test-qapi-types.c |
sed -n 's,^// \(.*\)MAX,s|\1MAX|\1_MAX|g,p' > list
$ git grep -l _MAX | xargs sed -i -f list
The only things not generated are the changes in scripts/qapi.py.
Rejecting enum members named 'MAX' is now useless, and will be dropped
in the next patch.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-23-git-send-email-eblake@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
[Rebased to current master, commit message tweaked]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 11:52:57 +03:00
|
|
|
for (i = 0; i < ENUM_ONE__MAX; i++) {
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_EnumOne(data->ov, "unused", &i, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qstr = qobject_to(QString, visitor_get(data));
|
2017-02-17 23:38:20 +03:00
|
|
|
g_assert(qstr);
|
2017-08-24 11:46:08 +03:00
|
|
|
g_assert_cmpstr(qstring_get_str(qstr), ==, EnumOne_str(i));
|
2016-05-10 07:20:06 +03:00
|
|
|
visitor_reset(data);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_struct(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
TestStruct test_struct = { .integer = 42,
|
|
|
|
|
.boolean = false,
|
|
|
|
|
.string = (char *) "foo"};
|
|
|
|
|
TestStruct *p = &test_struct;
|
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_TestStruct(data->ov, NULL, &p, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_size(qdict), ==, 3);
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 42);
|
2015-05-16 01:25:00 +03:00
|
|
|
g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, false);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "foo");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_struct_nested(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
int64_t value = 42;
|
2015-05-04 18:05:29 +03:00
|
|
|
UserDefTwo *ud2;
|
2011-11-15 01:05:29 +04:00
|
|
|
QDict *qdict, *dict1, *dict2, *dict3, *userdef;
|
|
|
|
|
const char *string = "user def string";
|
2012-02-25 16:47:10 +04:00
|
|
|
const char *strings[] = { "forty two", "forty three", "forty four",
|
|
|
|
|
"forty five" };
|
2011-11-15 01:05:29 +04:00
|
|
|
|
|
|
|
|
ud2 = g_malloc0(sizeof(*ud2));
|
|
|
|
|
ud2->string0 = g_strdup(strings[0]);
|
|
|
|
|
|
qapi: Drop tests for inline nested structs
A future patch will be using a 'name':{dictionary} entry in the
QAPI schema to specify a default value for an optional argument;
but existing use of inline nested structs conflicts with that goal.
More precisely, a definition in the QAPI schema associates a name
with a set of properties:
Example 1: { 'struct': 'Foo', 'data': { MEMBERS... } }
associates the global name 'Foo' with properties (meta-type struct)
and MEMBERS...
Example 2: 'mumble': TYPE
within MEMBERS... above associates 'mumble' with properties (type
TYPE) and (optional false) within type Foo
The syntax of example 1 is extensible; if we need another property,
we add another name/value pair to the dictionary (such as
'base':TYPE). The syntax of example 2 is not extensible, because
the right hand side can only be a type.
We have used name encoding to add a property: "'*mumble': 'int'"
associates 'mumble' with (type int) and (optional true). Nice,
but doesn't scale. So the solution is to change our existing uses
to be syntactic sugar to an extensible form:
NAME: TYPE --> NAME: { 'type': TYPE, 'optional': false }
*ONAME: TYPE --> ONAME: { 'type': TYPE, 'optional': true }
This patch fixes the testsuite to avoid inline nested types, by
breaking the nesting into explicit types; it means that the type
is now boxed instead of unboxed in C code, but makes no difference
on the wire (and if desired, a later patch could change the
generator to not do so much boxing in C). When touching code to
add new allocations, also convert existing allocations to
consistently prefer typesafe g_new0 over g_malloc0 when a type
name is involved.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-05-04 18:05:30 +03:00
|
|
|
ud2->dict1 = g_malloc0(sizeof(*ud2->dict1));
|
|
|
|
|
ud2->dict1->string1 = g_strdup(strings[1]);
|
|
|
|
|
|
|
|
|
|
ud2->dict1->dict2 = g_malloc0(sizeof(*ud2->dict1->dict2));
|
|
|
|
|
ud2->dict1->dict2->userdef = g_new0(UserDefOne, 1);
|
|
|
|
|
ud2->dict1->dict2->userdef->string = g_strdup(string);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud2->dict1->dict2->userdef->integer = value;
|
qapi: Drop tests for inline nested structs
A future patch will be using a 'name':{dictionary} entry in the
QAPI schema to specify a default value for an optional argument;
but existing use of inline nested structs conflicts with that goal.
More precisely, a definition in the QAPI schema associates a name
with a set of properties:
Example 1: { 'struct': 'Foo', 'data': { MEMBERS... } }
associates the global name 'Foo' with properties (meta-type struct)
and MEMBERS...
Example 2: 'mumble': TYPE
within MEMBERS... above associates 'mumble' with properties (type
TYPE) and (optional false) within type Foo
The syntax of example 1 is extensible; if we need another property,
we add another name/value pair to the dictionary (such as
'base':TYPE). The syntax of example 2 is not extensible, because
the right hand side can only be a type.
We have used name encoding to add a property: "'*mumble': 'int'"
associates 'mumble' with (type int) and (optional true). Nice,
but doesn't scale. So the solution is to change our existing uses
to be syntactic sugar to an extensible form:
NAME: TYPE --> NAME: { 'type': TYPE, 'optional': false }
*ONAME: TYPE --> ONAME: { 'type': TYPE, 'optional': true }
This patch fixes the testsuite to avoid inline nested types, by
breaking the nesting into explicit types; it means that the type
is now boxed instead of unboxed in C code, but makes no difference
on the wire (and if desired, a later patch could change the
generator to not do so much boxing in C). When touching code to
add new allocations, also convert existing allocations to
consistently prefer typesafe g_new0 over g_malloc0 when a type
name is involved.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-05-04 18:05:30 +03:00
|
|
|
ud2->dict1->dict2->string = g_strdup(strings[2]);
|
|
|
|
|
|
|
|
|
|
ud2->dict1->dict3 = g_malloc0(sizeof(*ud2->dict1->dict3));
|
|
|
|
|
ud2->dict1->dict3->userdef = g_new0(UserDefOne, 1);
|
|
|
|
|
ud2->dict1->dict3->userdef->string = g_strdup(string);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud2->dict1->dict3->userdef->integer = value;
|
qapi: Drop tests for inline nested structs
A future patch will be using a 'name':{dictionary} entry in the
QAPI schema to specify a default value for an optional argument;
but existing use of inline nested structs conflicts with that goal.
More precisely, a definition in the QAPI schema associates a name
with a set of properties:
Example 1: { 'struct': 'Foo', 'data': { MEMBERS... } }
associates the global name 'Foo' with properties (meta-type struct)
and MEMBERS...
Example 2: 'mumble': TYPE
within MEMBERS... above associates 'mumble' with properties (type
TYPE) and (optional false) within type Foo
The syntax of example 1 is extensible; if we need another property,
we add another name/value pair to the dictionary (such as
'base':TYPE). The syntax of example 2 is not extensible, because
the right hand side can only be a type.
We have used name encoding to add a property: "'*mumble': 'int'"
associates 'mumble' with (type int) and (optional true). Nice,
but doesn't scale. So the solution is to change our existing uses
to be syntactic sugar to an extensible form:
NAME: TYPE --> NAME: { 'type': TYPE, 'optional': false }
*ONAME: TYPE --> ONAME: { 'type': TYPE, 'optional': true }
This patch fixes the testsuite to avoid inline nested types, by
breaking the nesting into explicit types; it means that the type
is now boxed instead of unboxed in C code, but makes no difference
on the wire (and if desired, a later patch could change the
generator to not do so much boxing in C). When touching code to
add new allocations, also convert existing allocations to
consistently prefer typesafe g_new0 over g_malloc0 when a type
name is involved.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-05-04 18:05:30 +03:00
|
|
|
ud2->dict1->dict3->string = g_strdup(strings[3]);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_UserDefTwo(data->ov, "unused", &ud2, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_size(qdict), ==, 2);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "string0"), ==, strings[0]);
|
|
|
|
|
|
|
|
|
|
dict1 = qdict_get_qdict(qdict, "dict1");
|
|
|
|
|
g_assert_cmpint(qdict_size(dict1), ==, 3);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(dict1, "string1"), ==, strings[1]);
|
|
|
|
|
|
|
|
|
|
dict2 = qdict_get_qdict(dict1, "dict2");
|
|
|
|
|
g_assert_cmpint(qdict_size(dict2), ==, 2);
|
2015-05-04 18:05:29 +03:00
|
|
|
g_assert_cmpstr(qdict_get_str(dict2, "string"), ==, strings[2]);
|
|
|
|
|
userdef = qdict_get_qdict(dict2, "userdef");
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_size(userdef), ==, 2);
|
|
|
|
|
g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string);
|
|
|
|
|
|
|
|
|
|
dict3 = qdict_get_qdict(dict1, "dict3");
|
|
|
|
|
g_assert_cmpint(qdict_size(dict3), ==, 2);
|
2015-05-04 18:05:29 +03:00
|
|
|
g_assert_cmpstr(qdict_get_str(dict3, "string"), ==, strings[3]);
|
|
|
|
|
userdef = qdict_get_qdict(dict3, "userdef");
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_size(userdef), ==, 2);
|
|
|
|
|
g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string);
|
|
|
|
|
|
2015-05-04 18:05:29 +03:00
|
|
|
qapi_free_UserDefTwo(ud2);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_list(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
2015-11-06 09:35:26 +03:00
|
|
|
const char *value_str = "list value";
|
2020-11-13 04:13:37 +03:00
|
|
|
TestStruct *value;
|
|
|
|
|
TestStructList *head = NULL;
|
2011-11-15 01:05:29 +04:00
|
|
|
const int max_items = 10;
|
|
|
|
|
bool value_bool = true;
|
|
|
|
|
int value_int = 10;
|
|
|
|
|
QListEntry *entry;
|
|
|
|
|
QList *qlist;
|
|
|
|
|
int i;
|
|
|
|
|
|
2015-11-06 09:35:26 +03:00
|
|
|
/* Build the list in reverse order... */
|
2011-11-15 01:05:29 +04:00
|
|
|
for (i = 0; i < max_items; i++) {
|
2020-11-13 04:13:37 +03:00
|
|
|
value = g_malloc0(sizeof(*value));
|
|
|
|
|
value->integer = value_int + (max_items - i - 1);
|
|
|
|
|
value->boolean = value_bool;
|
|
|
|
|
value->string = g_strdup(value_str);
|
|
|
|
|
|
|
|
|
|
QAPI_LIST_PREPEND(head, value);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_TestStructList(data->ov, NULL, &head, &error_abort);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qlist = qobject_to(QList, visitor_get(data));
|
2017-02-17 23:38:19 +03:00
|
|
|
g_assert(qlist);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert(!qlist_empty(qlist));
|
|
|
|
|
|
2015-11-06 09:35:26 +03:00
|
|
|
/* ...and ensure that the visitor sees it in order */
|
2011-11-15 01:05:29 +04:00
|
|
|
i = 0;
|
|
|
|
|
QLIST_FOREACH_ENTRY(qlist, entry) {
|
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, entry->value);
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_size(qdict), ==, 3);
|
2015-11-06 09:35:26 +03:00
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, value_int + i);
|
2011-11-15 01:05:29 +04:00
|
|
|
g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, value_bool);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, value_str);
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
g_assert_cmpint(i, ==, max_items);
|
|
|
|
|
|
2015-11-06 09:35:26 +03:00
|
|
|
qapi_free_TestStructList(head);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_visitor_out_list_qapi_free(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
2020-11-13 04:13:37 +03:00
|
|
|
UserDefTwo *value;
|
|
|
|
|
UserDefTwoList *head = NULL;
|
2011-11-15 01:05:29 +04:00
|
|
|
const char string[] = "foo bar";
|
|
|
|
|
int i, max_count = 1024;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < max_count; i++) {
|
2020-11-13 04:13:37 +03:00
|
|
|
value = g_malloc0(sizeof(*value));
|
|
|
|
|
|
|
|
|
|
value->string0 = g_strdup(string);
|
|
|
|
|
value->dict1 = g_new0(UserDefTwoDict, 1);
|
|
|
|
|
value->dict1->string1 = g_strdup(string);
|
|
|
|
|
value->dict1->dict2 = g_new0(UserDefTwoDictDict, 1);
|
|
|
|
|
value->dict1->dict2->userdef = g_new0(UserDefOne, 1);
|
|
|
|
|
value->dict1->dict2->userdef->string = g_strdup(string);
|
|
|
|
|
value->dict1->dict2->userdef->integer = 42;
|
|
|
|
|
value->dict1->dict2->string = g_strdup(string);
|
|
|
|
|
|
|
|
|
|
QAPI_LIST_PREPEND(head, value);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
2015-05-04 18:05:29 +03:00
|
|
|
qapi_free_UserDefTwoList(head);
|
2011-11-15 01:05:29 +04:00
|
|
|
}
|
|
|
|
|
|
2015-09-16 14:06:24 +03:00
|
|
|
static void test_visitor_out_any(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
QObject *qobj;
|
2017-06-07 19:35:58 +03:00
|
|
|
QNum *qnum;
|
2015-09-16 14:06:24 +03:00
|
|
|
QBool *qbool;
|
|
|
|
|
QString *qstring;
|
|
|
|
|
QDict *qdict;
|
2017-06-07 19:35:58 +03:00
|
|
|
int64_t val;
|
2015-09-16 14:06:24 +03:00
|
|
|
|
2017-06-07 19:35:58 +03:00
|
|
|
qobj = QOBJECT(qnum_from_int(-42));
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_any(data->ov, NULL, &qobj, &error_abort);
|
2018-02-24 18:40:29 +03:00
|
|
|
qnum = qobject_to(QNum, visitor_get(data));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum);
|
|
|
|
|
g_assert(qnum_get_try_int(qnum, &val));
|
|
|
|
|
g_assert_cmpint(val, ==, -42);
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(qobj);
|
2015-09-16 14:06:24 +03:00
|
|
|
|
2016-05-10 07:20:06 +03:00
|
|
|
visitor_reset(data);
|
2015-09-16 14:06:24 +03:00
|
|
|
qdict = qdict_new();
|
2017-04-28 00:58:17 +03:00
|
|
|
qdict_put_int(qdict, "integer", -42);
|
|
|
|
|
qdict_put_bool(qdict, "boolean", true);
|
|
|
|
|
qdict_put_str(qdict, "string", "foo");
|
2015-09-16 14:06:24 +03:00
|
|
|
qobj = QOBJECT(qdict);
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_any(data->ov, NULL, &qobj, &error_abort);
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(qobj);
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2015-09-16 14:06:24 +03:00
|
|
|
g_assert(qdict);
|
2018-02-24 18:40:29 +03:00
|
|
|
qnum = qobject_to(QNum, qdict_get(qdict, "integer"));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum);
|
|
|
|
|
g_assert(qnum_get_try_int(qnum, &val));
|
|
|
|
|
g_assert_cmpint(val, ==, -42);
|
2018-02-24 18:40:29 +03:00
|
|
|
qbool = qobject_to(QBool, qdict_get(qdict, "boolean"));
|
2015-09-16 14:06:24 +03:00
|
|
|
g_assert(qbool);
|
|
|
|
|
g_assert(qbool_get_bool(qbool) == true);
|
2018-02-24 18:40:29 +03:00
|
|
|
qstring = qobject_to(QString, qdict_get(qdict, "string"));
|
2015-09-16 14:06:24 +03:00
|
|
|
g_assert(qstring);
|
|
|
|
|
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-01 11:40:33 +04:00
|
|
|
static void test_visitor_out_union_flat(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
2022-03-15 17:41:56 +03:00
|
|
|
UserDefFlatUnion *tmp = g_new0(UserDefFlatUnion, 1);
|
2015-07-31 11:30:04 +03:00
|
|
|
tmp->enum1 = ENUM_ONE_VALUE1;
|
2014-03-05 06:44:39 +04:00
|
|
|
tmp->string = g_strdup("str");
|
2015-10-27 01:34:53 +03:00
|
|
|
tmp->integer = 41;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 09:48:27 +03:00
|
|
|
tmp->u.value1.boolean = true;
|
2014-03-01 11:40:33 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_UserDefFlatUnion(data->ov, NULL, &tmp, &error_abort);
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2014-03-05 06:44:39 +04:00
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1");
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str");
|
2015-10-27 01:34:53 +03:00
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 41);
|
2014-03-01 11:40:33 +04:00
|
|
|
g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true);
|
|
|
|
|
|
|
|
|
|
qapi_free_UserDefFlatUnion(tmp);
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-20 13:26:19 +03:00
|
|
|
static void test_visitor_out_union_in_union(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
|
|
|
|
{
|
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
|
|
|
|
TestUnionInUnion *tmp = g_new0(TestUnionInUnion, 1);
|
|
|
|
|
tmp->type = TEST_UNION_ENUM_VALUE_A;
|
|
|
|
|
tmp->u.value_a.type_a = TEST_UNION_ENUMA_VALUE_A1;
|
|
|
|
|
tmp->u.value_a.u.value_a1.integer = 42;
|
|
|
|
|
tmp->u.value_a.u.value_a1.name = g_strdup("fish");
|
|
|
|
|
|
|
|
|
|
visit_type_TestUnionInUnion(data->ov, NULL, &tmp, &error_abort);
|
|
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
|
|
|
|
g_assert(qdict);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "type"), ==, "value-a");
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "type-a"), ==, "value-a1");
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 42);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "name"), ==, "fish");
|
|
|
|
|
|
|
|
|
|
qapi_free_TestUnionInUnion(tmp);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
visitor_reset(data);
|
|
|
|
|
tmp = g_new0(TestUnionInUnion, 1);
|
|
|
|
|
tmp->type = TEST_UNION_ENUM_VALUE_A;
|
|
|
|
|
tmp->u.value_a.type_a = TEST_UNION_ENUMA_VALUE_A2;
|
|
|
|
|
tmp->u.value_a.u.value_a2.integer = 1729;
|
|
|
|
|
tmp->u.value_a.u.value_a2.size = 87539319;
|
|
|
|
|
|
|
|
|
|
visit_type_TestUnionInUnion(data->ov, NULL, &tmp, &error_abort);
|
|
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
|
|
|
|
g_assert(qdict);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "type"), ==, "value-a");
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "type-a"), ==, "value-a2");
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1729);
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "size"), ==, 87539319);
|
|
|
|
|
|
|
|
|
|
qapi_free_TestUnionInUnion(tmp);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
visitor_reset(data);
|
|
|
|
|
tmp = g_new0(TestUnionInUnion, 1);
|
|
|
|
|
tmp->type = TEST_UNION_ENUM_VALUE_B;
|
|
|
|
|
tmp->u.value_b.integer = 1729;
|
|
|
|
|
tmp->u.value_b.onoff = true;
|
|
|
|
|
|
|
|
|
|
visit_type_TestUnionInUnion(data->ov, NULL, &tmp, &error_abort);
|
|
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
|
|
|
|
g_assert(qdict);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "type"), ==, "value-b");
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1729);
|
|
|
|
|
g_assert_cmpint(qdict_get_bool(qdict, "onoff"), ==, true);
|
|
|
|
|
|
|
|
|
|
qapi_free_TestUnionInUnion(tmp);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-04 18:05:11 +03:00
|
|
|
static void test_visitor_out_alternate(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
2014-03-01 11:40:30 +04:00
|
|
|
{
|
2015-11-06 09:35:32 +03:00
|
|
|
UserDefAlternate *tmp;
|
2017-06-07 19:35:58 +03:00
|
|
|
QNum *qnum;
|
2017-02-17 23:38:20 +03:00
|
|
|
QString *qstr;
|
2016-02-18 09:48:18 +03:00
|
|
|
QDict *qdict;
|
2017-06-07 19:35:58 +03:00
|
|
|
int64_t val;
|
2014-03-01 11:40:30 +04:00
|
|
|
|
2015-11-06 09:35:32 +03:00
|
|
|
tmp = g_new0(UserDefAlternate, 1);
|
2017-06-07 19:35:58 +03:00
|
|
|
tmp->type = QTYPE_QNUM;
|
2015-10-27 01:34:53 +03:00
|
|
|
tmp->u.i = 42;
|
2014-03-01 11:40:30 +04:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
|
2018-02-24 18:40:29 +03:00
|
|
|
qnum = qobject_to(QNum, visitor_get(data));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum);
|
|
|
|
|
g_assert(qnum_get_try_int(qnum, &val));
|
|
|
|
|
g_assert_cmpint(val, ==, 42);
|
2014-03-01 11:40:30 +04:00
|
|
|
|
2015-05-04 18:05:11 +03:00
|
|
|
qapi_free_UserDefAlternate(tmp);
|
2015-11-06 09:35:32 +03:00
|
|
|
|
2016-05-10 07:20:06 +03:00
|
|
|
visitor_reset(data);
|
2015-11-06 09:35:32 +03:00
|
|
|
tmp = g_new0(UserDefAlternate, 1);
|
qapi: Simplify visiting of alternate types
Previously, working with alternates required two lookup arrays
and some indirection: for type Foo, we created Foo_qtypes[]
which maps each qtype to a value of the generated FooKind enum,
then look up that value in FooKind_lookup[] like we do for other
union types.
This has a couple of subtle bugs. First, the generator was
creating a call with a parameter '(int *) &(*obj)->type' where
type is an enum type; this is unsafe if the compiler chooses
to store the enum type in a different size than int, where
assigning through the wrong size pointer can corrupt data or
cause a SIGBUS.
Related bug, not not fixed in this patch: qapi-visit.py's
gen_visit_enum() generates a cast of its enum * argument to
int *. Marked FIXME.
Second, since the values of the FooKind enum start at zero, all
entries of the Foo_qtypes[] array that were not explicitly
initialized will map to the same branch of the union as the
first member of the alternate, rather than triggering a desired
failure in visit_get_next_type(). Fortunately, the bug seldom
bites; the very next thing the input visitor does is try to
parse the incoming JSON with the wrong parser, which normally
fails; the output visitor is not used with a C struct in that
state, and the dealloc visitor has nothing to clean up (so
there is no leak).
However, the second bug IS observable in one case: parsing an
integer causes unusual behavior in an alternate that contains
at least a 'number' member but no 'int' member, because the
'number' parser accepts QTYPE_QINT in addition to the expected
QTYPE_QFLOAT (that is, since 'int' is not a member, the type
QTYPE_QINT accidentally maps to FooKind 0; if this enum value
is the 'number' branch the integer parses successfully, but if
the 'number' branch is not first, some other branch tries to
parse the integer and rejects it). A later patch will worry
about fixing alternates to always parse all inputs that a
non-alternate 'number' would accept, for now this is still
marked FIXME in the updated test-qmp-input-visitor.c, to
merely point out that new undesired behavior of 'ans' matches
the existing undesired behavior of 'asn'.
This patch fixes the default-initialization bug by deleting the
indirection, and modifying get_next_type() to directly assign a
QTypeCode parameter. This in turn fixes the type-casting bug,
as we are no longer casting a pointer to enum to a questionable
size. There is no longer a need to generate an implicit FooKind
enum associated with the alternate type (since the QMP wire
format never uses the stringized counterparts of the C union
member names). Since the updated visit_get_next_type() does not
know which qtypes are expected, the generated visitor is
modified to generate an error statement if an unexpected type is
encountered.
Callers now have to know the QTYPE_* mapping when looking at the
discriminator; but so far, only the testsuite was even using the
C struct of an alternate types. I considered the possibility of
keeping the internal enum FooKind, but initialized differently
than most generated arrays, as in:
typedef enum FooKind {
FOO_KIND_A = QTYPE_QDICT,
FOO_KIND_B = QTYPE_QINT,
} FooKind;
to create nicer aliases for knowing when to use foo->a or foo->b
when inspecting foo->type; but it turned out to add too much
complexity, especially without a client.
There is a user-visible side effect to this change, but I
consider it to be an improvement. Previously,
the invalid QMP command:
{"execute":"blockdev-add", "arguments":{"options":
{"driver":"raw", "id":"a", "file":true}}}
failed with:
{"error": {"class": "GenericError",
"desc": "Invalid parameter type for 'file', expected: QDict"}}
(visit_get_next_type() succeeded, and the error comes from the
visit_type_BlockdevOptions() expecting {}; there is no mention of
the fact that a string would also work). Now it fails with:
{"error": {"class": "GenericError",
"desc": "Invalid parameter type for 'file', expected: BlockdevRef"}}
(the error when the next type doesn't match any expected types for
the overall alternate).
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1449033659-25497-5-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-12-02 08:20:48 +03:00
|
|
|
tmp->type = QTYPE_QSTRING;
|
2017-05-22 19:42:14 +03:00
|
|
|
tmp->u.e = ENUM_ONE_VALUE1;
|
2015-11-06 09:35:32 +03:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 16:48:54 +03:00
|
|
|
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
|
2018-02-24 18:40:29 +03:00
|
|
|
qstr = qobject_to(QString, visitor_get(data));
|
2017-02-17 23:38:20 +03:00
|
|
|
g_assert(qstr);
|
2017-05-22 19:42:14 +03:00
|
|
|
g_assert_cmpstr(qstring_get_str(qstr), ==, "value1");
|
2015-11-06 09:35:32 +03:00
|
|
|
|
|
|
|
|
qapi_free_UserDefAlternate(tmp);
|
2016-02-18 09:48:18 +03:00
|
|
|
|
2017-06-26 20:25:14 +03:00
|
|
|
visitor_reset(data);
|
|
|
|
|
tmp = g_new0(UserDefAlternate, 1);
|
|
|
|
|
tmp->type = QTYPE_QNULL;
|
|
|
|
|
tmp->u.n = qnull();
|
|
|
|
|
|
|
|
|
|
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
|
|
|
|
|
g_assert_cmpint(qobject_type(visitor_get(data)), ==, QTYPE_QNULL);
|
|
|
|
|
|
|
|
|
|
qapi_free_UserDefAlternate(tmp);
|
|
|
|
|
|
2016-05-10 07:20:06 +03:00
|
|
|
visitor_reset(data);
|
2016-02-18 09:48:18 +03:00
|
|
|
tmp = g_new0(UserDefAlternate, 1);
|
|
|
|
|
tmp->type = QTYPE_QDICT;
|
qapi: Don't box struct branch of alternate
There's no reason to do two malloc's for an alternate type visiting
a QAPI struct; let's just inline the struct directly as the C union
branch of the struct.
Surprisingly, no clients were actually using the struct member prior
to this patch outside of the testsuite; an earlier patch in the series
added some testsuite coverage to make the effect of this patch more
obvious.
In qapi.py, c_type() gains a new is_unboxed flag to control when we
are emitting a C struct unboxed within the context of an outer
struct (different from our other two modes of usage with no flags
for normal local variable declarations, and with is_param for adding
'const' in a parameter list). I don't know if there is any more
pythonic way of collapsing the two flags into a single parameter,
as we never have a caller setting both flags at once.
Ultimately, we want to also unbox branches for QAPI unions, but as
that touches a lot more client code, it is better as separate
patches. But since unions and alternates share gen_variants(), I
had to hack in a way to test if we are visiting an alternate type
for setting the is_unboxed flag: look for a non-object branch.
This works because alternates have at least two branches, with at
most one object branch, while unions have only object branches.
The hack will go away in a later patch.
The generated code difference to qapi-types.h is relatively small:
| struct BlockdevRef {
| QType type;
| union { /* union tag is @type */
| void *data;
|- BlockdevOptions *definition;
|+ BlockdevOptions definition;
| char *reference;
| } u;
| };
The corresponding spot in qapi-visit.c calls visit_type_FOO(), which
first calls visit_start_struct() to allocate or deallocate the member
and handle a layer of {} from the JSON stream, then visits the
members. To peel off the indirection and the memory management that
comes with it, we inline this call, then suppress allocation /
deallocation by passing NULL to visit_start_struct(), and adjust the
member visit:
| switch ((*obj)->type) {
| case QTYPE_QDICT:
|- visit_type_BlockdevOptions(v, name, &(*obj)->u.definition, &err);
|+ visit_start_struct(v, name, NULL, 0, &err);
|+ if (err) {
|+ break;
|+ }
|+ visit_type_BlockdevOptions_fields(v, &(*obj)->u.definition, &err);
|+ error_propagate(errp, err);
|+ err = NULL;
|+ visit_end_struct(v, &err);
| break;
| case QTYPE_QSTRING:
| visit_type_str(v, name, &(*obj)->u.reference, &err);
The visit of non-object fields is unchanged.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-13-git-send-email-eblake@redhat.com>
[Commit message tweaked]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 09:48:26 +03:00
|
|
|
tmp->u.udfu.integer = 1;
|
|
|
|
|
tmp->u.udfu.string = g_strdup("str");
|
|
|
|
|
tmp->u.udfu.enum1 = ENUM_ONE_VALUE1;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 09:48:27 +03:00
|
|
|
tmp->u.udfu.u.value1.boolean = true;
|
2016-02-18 09:48:18 +03:00
|
|
|
|
|
|
|
|
visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2016-02-18 09:48:18 +03:00
|
|
|
g_assert_cmpint(qdict_size(qdict), ==, 4);
|
|
|
|
|
g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1);
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str");
|
|
|
|
|
g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1");
|
|
|
|
|
g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true);
|
|
|
|
|
|
|
|
|
|
qapi_free_UserDefAlternate(tmp);
|
2014-03-01 11:40:30 +04:00
|
|
|
}
|
|
|
|
|
|
2016-04-29 00:45:23 +03:00
|
|
|
static void test_visitor_out_null(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
2014-05-26 16:40:56 +04:00
|
|
|
{
|
2017-06-26 19:22:59 +03:00
|
|
|
QNull *null = NULL;
|
2016-04-29 00:45:23 +03:00
|
|
|
QDict *qdict;
|
|
|
|
|
QObject *nil;
|
2014-05-26 16:40:56 +04:00
|
|
|
|
2016-04-29 00:45:23 +03:00
|
|
|
visit_start_struct(data->ov, NULL, NULL, 0, &error_abort);
|
2017-06-26 19:22:59 +03:00
|
|
|
visit_type_null(data->ov, "a", &null, &error_abort);
|
qapi: Split visit_end_struct() into pieces
As mentioned in previous patches, we want to call visit_end_struct()
functions unconditionally, so that visitors can release resources
tied up since the matching visit_start_struct() without also having
to worry about error priority if more than one error occurs.
Even though error_propagate() can be safely used to ignore a second
error during cleanup caused by a first error, it is simpler if the
cleanup cannot set an error. So, split out the error checking
portion (basically, input visitors checking for unvisited keys) into
a new function visit_check_struct(), which can be safely skipped if
any earlier errors are encountered, and leave the cleanup portion
(which never fails, but must be called unconditionally if
visit_start_struct() succeeded) in visit_end_struct().
Generated code in qapi-visit.c has diffs resembling:
|@@ -59,10 +59,12 @@ void visit_type_ACPIOSTInfo(Visitor *v,
| goto out_obj;
| }
| visit_type_ACPIOSTInfo_members(v, obj, &err);
|- error_propagate(errp, err);
|- err = NULL;
|+ if (err) {
|+ goto out_obj;
|+ }
|+ visit_check_struct(v, &err);
| out_obj:
|- visit_end_struct(v, &err);
|+ visit_end_struct(v);
| out:
and in qapi-event.c:
@@ -47,7 +47,10 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
| visit_type_q_obj_ACPI_DEVICE_OST_arg_members(v, ¶m, &err);
|- visit_end_struct(v, err ? NULL : &err);
|+ if (!err) {
|+ visit_check_struct(v, &err);
|+ }
|+ visit_end_struct(v);
| if (err) {
| goto out;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1461879932-9020-20-git-send-email-eblake@redhat.com>
[Conflict with a doc fixup resolved]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-04-29 00:45:27 +03:00
|
|
|
visit_check_struct(data->ov, &error_abort);
|
qapi: Add parameter to visit_end_*
Rather than making the dealloc visitor track of stack of pointers
remembered during visit_start_* in order to free them during
visit_end_*, it's a lot easier to just make all callers pass the
same pointer to visit_end_*. The generated code has access to the
same pointer, while all other users are doing virtual walks and
can pass NULL. The dealloc visitor is then greatly simplified.
All three visit_end_*() functions intentionally take a void**,
even though the visit_start_*() functions differ between void**,
GenericList**, and GenericAlternate**. This is done for several
reasons: when doing a virtual walk, passing NULL doesn't care
what the type is, but when doing a generated walk, we already
have to cast the caller's specific FOO* to call visit_start,
while using void** lets us use visit_end without a cast. Also,
an upcoming patch will add a clone visitor that wants to use
the same implementation for all three visit_end callbacks,
which is made easier if all three share the same signature.
For visitors with already track per-object state (the QMP visitors
via a stack, and the string visitors which do not allow nesting),
add an assertion that the caller is indeed passing the same
pointer to paired calls.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-4-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 19:48:34 +03:00
|
|
|
visit_end_struct(data->ov, NULL);
|
2018-02-24 18:40:29 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2017-02-17 23:38:18 +03:00
|
|
|
g_assert(qdict);
|
2016-04-29 00:45:23 +03:00
|
|
|
g_assert_cmpint(qdict_size(qdict), ==, 1);
|
|
|
|
|
nil = qdict_get(qdict, "a");
|
|
|
|
|
g_assert(nil);
|
|
|
|
|
g_assert(qobject_type(nil) == QTYPE_QNULL);
|
2014-05-26 16:40:56 +04:00
|
|
|
}
|
|
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
static void test_visitor_out_list_struct(TestOutputVisitorData *data,
|
|
|
|
|
const void *unused)
|
2013-05-11 02:46:09 +04:00
|
|
|
{
|
2021-09-17 17:31:24 +03:00
|
|
|
const char *int_member[] = {
|
|
|
|
|
"integer", "s8", "s16", "s32", "s64", "u8", "u16", "u32", "u64" };
|
|
|
|
|
g_autoptr(ArrayStruct) arrs = g_new0(ArrayStruct, 1);
|
|
|
|
|
int i, j;
|
|
|
|
|
QDict *qdict;
|
|
|
|
|
QList *qlist;
|
|
|
|
|
QListEntry *e;
|
|
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->integer, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->s8, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->s16, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->s32, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->s64, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->u8, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->u16, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->u32, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->u64, i);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->number, (double)i / 3);
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->boolean, QEMU_IS_ALIGNED(i, 3));
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 31; i >= 0; i--) {
|
|
|
|
|
QAPI_LIST_PREPEND(arrs->string, g_strdup_printf("%d", i));
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
|
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
visit_type_ArrayStruct(data->ov, NULL, &arrs, &error_abort);
|
2013-05-11 02:46:09 +04:00
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
qdict = qobject_to(QDict, visitor_get(data));
|
2013-05-11 02:46:09 +04:00
|
|
|
g_assert(qdict);
|
2021-09-17 17:31:24 +03:00
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS(int_member); i++) {
|
|
|
|
|
qlist = qdict_get_qlist(qdict, int_member[i]);
|
|
|
|
|
g_assert(qlist);
|
|
|
|
|
j = 0;
|
|
|
|
|
QLIST_FOREACH_ENTRY(qlist, e) {
|
|
|
|
|
QNum *qvalue = qobject_to(QNum, qlist_entry_obj(e));
|
|
|
|
|
g_assert(qvalue);
|
|
|
|
|
g_assert_cmpint(qnum_get_int(qvalue), ==, j);
|
|
|
|
|
j++;
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
qlist = qdict_get_qlist(qdict, "number");
|
|
|
|
|
g_assert(qlist);
|
|
|
|
|
i = 0;
|
|
|
|
|
QLIST_FOREACH_ENTRY(qlist, e) {
|
|
|
|
|
QNum *qvalue = qobject_to(QNum, qlist_entry_obj(e));
|
|
|
|
|
char expected[32], actual[32];
|
|
|
|
|
|
|
|
|
|
g_assert(qvalue);
|
|
|
|
|
sprintf(expected, "%.6f", (double)i / 3);
|
|
|
|
|
sprintf(actual, "%.6f", qnum_get_double(qvalue));
|
|
|
|
|
g_assert_cmpstr(actual, ==, expected);
|
|
|
|
|
i++;
|
|
|
|
|
}
|
2013-05-11 02:46:09 +04:00
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
qlist = qdict_get_qlist(qdict, "boolean");
|
|
|
|
|
g_assert(qlist);
|
|
|
|
|
i = 0;
|
|
|
|
|
QLIST_FOREACH_ENTRY(qlist, e) {
|
|
|
|
|
QBool *qvalue = qobject_to(QBool, qlist_entry_obj(e));
|
|
|
|
|
g_assert(qvalue);
|
|
|
|
|
g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0);
|
|
|
|
|
i++;
|
|
|
|
|
}
|
2013-05-11 02:46:09 +04:00
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
qlist = qdict_get_qlist(qdict, "string");
|
|
|
|
|
g_assert(qlist);
|
|
|
|
|
i = 0;
|
|
|
|
|
QLIST_FOREACH_ENTRY(qlist, e) {
|
|
|
|
|
QString *qvalue = qobject_to(QString, qlist_entry_obj(e));
|
|
|
|
|
char expected[32];
|
2013-05-11 02:46:09 +04:00
|
|
|
|
2021-09-17 17:31:24 +03:00
|
|
|
g_assert(qvalue);
|
|
|
|
|
sprintf(expected, "%d", i);
|
|
|
|
|
g_assert_cmpstr(qstring_get_str(qvalue), ==, expected);
|
|
|
|
|
i++;
|
|
|
|
|
}
|
2013-05-11 02:46:09 +04:00
|
|
|
}
|
|
|
|
|
|
2011-11-15 01:05:29 +04:00
|
|
|
static void output_visitor_test_add(const char *testpath,
|
|
|
|
|
TestOutputVisitorData *data,
|
|
|
|
|
void (*test_func)(TestOutputVisitorData *data, const void *user_data))
|
|
|
|
|
{
|
|
|
|
|
g_test_add(testpath, TestOutputVisitorData, data, visitor_output_setup,
|
|
|
|
|
test_func, visitor_output_teardown);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
|
{
|
|
|
|
|
TestOutputVisitorData out_visitor_data;
|
|
|
|
|
|
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
|
|
|
|
|
|
|
|
output_visitor_test_add("/visitor/output/int",
|
|
|
|
|
&out_visitor_data, test_visitor_out_int);
|
|
|
|
|
output_visitor_test_add("/visitor/output/bool",
|
|
|
|
|
&out_visitor_data, test_visitor_out_bool);
|
|
|
|
|
output_visitor_test_add("/visitor/output/number",
|
|
|
|
|
&out_visitor_data, test_visitor_out_number);
|
|
|
|
|
output_visitor_test_add("/visitor/output/string",
|
|
|
|
|
&out_visitor_data, test_visitor_out_string);
|
|
|
|
|
output_visitor_test_add("/visitor/output/no-string",
|
|
|
|
|
&out_visitor_data, test_visitor_out_no_string);
|
|
|
|
|
output_visitor_test_add("/visitor/output/enum",
|
|
|
|
|
&out_visitor_data, test_visitor_out_enum);
|
|
|
|
|
output_visitor_test_add("/visitor/output/struct",
|
|
|
|
|
&out_visitor_data, test_visitor_out_struct);
|
|
|
|
|
output_visitor_test_add("/visitor/output/struct-nested",
|
|
|
|
|
&out_visitor_data, test_visitor_out_struct_nested);
|
|
|
|
|
output_visitor_test_add("/visitor/output/list",
|
|
|
|
|
&out_visitor_data, test_visitor_out_list);
|
2015-09-16 14:06:24 +03:00
|
|
|
output_visitor_test_add("/visitor/output/any",
|
|
|
|
|
&out_visitor_data, test_visitor_out_any);
|
2011-11-15 01:05:29 +04:00
|
|
|
output_visitor_test_add("/visitor/output/list-qapi-free",
|
|
|
|
|
&out_visitor_data, test_visitor_out_list_qapi_free);
|
2014-03-01 11:40:33 +04:00
|
|
|
output_visitor_test_add("/visitor/output/union-flat",
|
|
|
|
|
&out_visitor_data, test_visitor_out_union_flat);
|
2023-04-20 13:26:19 +03:00
|
|
|
output_visitor_test_add("/visitor/output/union-in-union",
|
|
|
|
|
&out_visitor_data, test_visitor_out_union_in_union);
|
2015-05-04 18:05:11 +03:00
|
|
|
output_visitor_test_add("/visitor/output/alternate",
|
|
|
|
|
&out_visitor_data, test_visitor_out_alternate);
|
2016-04-29 00:45:23 +03:00
|
|
|
output_visitor_test_add("/visitor/output/null",
|
|
|
|
|
&out_visitor_data, test_visitor_out_null);
|
2021-09-17 17:31:24 +03:00
|
|
|
output_visitor_test_add("/visitor/output/list_struct",
|
|
|
|
|
&out_visitor_data, test_visitor_out_list_struct);
|
2011-11-15 01:05:29 +04:00
|
|
|
|
|
|
|
|
g_test_run();
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|