motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-06 17:23:56 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

qapi: Swap visit_* arguments for consistent 'name' placement

Browse source 
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>
This commit is contained in:
Eric Blake 2016-01-29 06:48:54 -07:00 • committed by Markus Armbruster
parent 4fa45492c3
commit 51e72bc1dd
52 changed files with 385 additions and 371 deletions
Download patch file Download diff file Expand all files Collapse all files

54
tests/test-visitor-serialization.c
View file

@ -101,40 +101,40 @@ static void visit_primitive_type(Visitor *v, void **native, Error **errp)
PrimitiveType *pt = *native;
switch(pt->type) {
case PTYPE_STRING:
visit_type_str(v, (char **)&pt->value.string, NULL, errp);
visit_type_str(v, NULL, (char **)&pt->value.string, errp);
break;
case PTYPE_BOOLEAN:
visit_type_bool(v, &pt->value.boolean, NULL, errp);
visit_type_bool(v, NULL, &pt->value.boolean, errp);
break;
case PTYPE_NUMBER:
visit_type_number(v, &pt->value.number, NULL, errp);
visit_type_number(v, NULL, &pt->value.number, errp);
break;
case PTYPE_INTEGER:
visit_type_int(v, &pt->value.integer, NULL, errp);
visit_type_int(v, NULL, &pt->value.integer, errp);
break;
case PTYPE_U8:
visit_type_uint8(v, &pt->value.u8, NULL, errp);
visit_type_uint8(v, NULL, &pt->value.u8, errp);
break;
case PTYPE_U16:
visit_type_uint16(v, &pt->value.u16, NULL, errp);
visit_type_uint16(v, NULL, &pt->value.u16, errp);
break;
case PTYPE_U32:
visit_type_uint32(v, &pt->value.u32, NULL, errp);
visit_type_uint32(v, NULL, &pt->value.u32, errp);
break;
case PTYPE_U64:
visit_type_uint64(v, &pt->value.u64, NULL, errp);
visit_type_uint64(v, NULL, &pt->value.u64, errp);
break;
case PTYPE_S8:
visit_type_int8(v, &pt->value.s8, NULL, errp);
visit_type_int8(v, NULL, &pt->value.s8, errp);
break;
case PTYPE_S16:
visit_type_int16(v, &pt->value.s16, NULL, errp);
visit_type_int16(v, NULL, &pt->value.s16, errp);
break;
case PTYPE_S32:
visit_type_int32(v, &pt->value.s32, NULL, errp);
visit_type_int32(v, NULL, &pt->value.s32, errp);
break;
case PTYPE_S64:
visit_type_int64(v, &pt->value.s64, NULL, errp);
visit_type_int64(v, NULL, &pt->value.s64, errp);
break;
case PTYPE_EOL:
g_assert_not_reached();
@ -146,40 +146,40 @@ static void visit_primitive_list(Visitor *v, void **native, Error **errp)
PrimitiveList *pl = *native;
switch (pl->type) {
case PTYPE_STRING:
visit_type_strList(v, &pl->value.strings, NULL, errp);
visit_type_strList(v, NULL, &pl->value.strings, errp);
break;
case PTYPE_BOOLEAN:
visit_type_boolList(v, &pl->value.booleans, NULL, errp);
visit_type_boolList(v, NULL, &pl->value.booleans, errp);
break;
case PTYPE_NUMBER:
visit_type_numberList(v, &pl->value.numbers, NULL, errp);
visit_type_numberList(v, NULL, &pl->value.numbers, errp);
break;
case PTYPE_INTEGER:
visit_type_intList(v, &pl->value.integers, NULL, errp);
visit_type_intList(v, NULL, &pl->value.integers, errp);
break;
case PTYPE_S8:
visit_type_int8List(v, &pl->value.s8_integers, NULL, errp);
visit_type_int8List(v, NULL, &pl->value.s8_integers, errp);
break;
case PTYPE_S16:
visit_type_int16List(v, &pl->value.s16_integers, NULL, errp);
visit_type_int16List(v, NULL, &pl->value.s16_integers, errp);
break;
case PTYPE_S32:
visit_type_int32List(v, &pl->value.s32_integers, NULL, errp);
visit_type_int32List(v, NULL, &pl->value.s32_integers, errp);
break;
case PTYPE_S64:
visit_type_int64List(v, &pl->value.s64_integers, NULL, errp);
visit_type_int64List(v, NULL, &pl->value.s64_integers, errp);
break;
case PTYPE_U8:
visit_type_uint8List(v, &pl->value.u8_integers, NULL, errp);
visit_type_uint8List(v, NULL, &pl->value.u8_integers, errp);
break;
case PTYPE_U16:
visit_type_uint16List(v, &pl->value.u16_integers, NULL, errp);
visit_type_uint16List(v, NULL, &pl->value.u16_integers, errp);
break;
case PTYPE_U32:
visit_type_uint32List(v, &pl->value.u32_integers, NULL, errp);
visit_type_uint32List(v, NULL, &pl->value.u32_integers, errp);
break;
case PTYPE_U64:
visit_type_uint64List(v, &pl->value.u64_integers, NULL, errp);
visit_type_uint64List(v, NULL, &pl->value.u64_integers, errp);
break;
default:
g_assert_not_reached();
@ -213,7 +213,7 @@ static void struct_cleanup(TestStruct *ts)
static void visit_struct(Visitor *v, void **native, Error **errp)
{
visit_type_TestStruct(v, (TestStruct **)native, NULL, errp);
visit_type_TestStruct(v, NULL, (TestStruct **)native, errp);
}
static UserDefTwo *nested_struct_create(void)
@ -264,12 +264,12 @@ static void nested_struct_cleanup(UserDefTwo *udnp)
static void visit_nested_struct(Visitor *v, void **native, Error **errp)
{
visit_type_UserDefTwo(v, (UserDefTwo **)native, NULL, errp);
visit_type_UserDefTwo(v, NULL, (UserDefTwo **)native, errp);
}
static void visit_nested_struct_list(Visitor *v, void **native, Error **errp)
{
visit_type_UserDefTwoList(v, (UserDefTwoList **)native, NULL, errp);
visit_type_UserDefTwoList(v, NULL, (UserDefTwoList **)native, errp);
}
/* test cases */