Eric Blake <ebl...@redhat.com> writes:
> Refactor the code to advance the QListEntry pointer at the point
> where visit_type_FOO() is called, rather than visit_next_list().
> This will allow a future patch to move the visit of the list head
> into visit_start_list(), and get rid of the 'first' flag.
>
> Signed-off-by: Eric Blake <ebl...@redhat.com>
After having read the patch, I think the change is from this sequence of
states
start_list next_list type_ELT ... next_list type_ELT end_list
entry NULL 1st elt 1st elt last elt last elt gone
where type_ELT() returns (entry ? entry : 1st elt) and next_list() steps
entry
to this one
start_list next_list type_ELT ... next_list type_ELT end_list
entry 1st elt 1nd elt 2nd elt last elt NULL gone
where type_ELT() steps entry and returns the old entry, and next_list()
leaves entry alone. Correct?
Now have a look at the typical generated visit:
void visit_type_FOOList(Visitor *v, const char *name, FOOList **obj, Error
**errp)
{
Error *err = NULL;
FOOList *tail;
size_t size = sizeof(**obj);
visit_start_list(v, name, (GenericList **)obj, size, &err);
if (err) {
goto out;
}
for (tail = *obj;
tail;
tail = (FOOList *)visit_next_list(v, (GenericList *)tail, size)) {
visit_type_FOO(v, NULL, &tail->value, &err);
if (err) {
break;
}
}
if (visit_end_list(v) && err) {
qapi_free_FOOList(*obj);
*obj = NULL;
}
out:
error_propagate(errp, err);
}
While the loop variable is still stepped in the for's third expression
as it should, the actual stepping below the hood now happens in the loop
body. I find this mildly confusing.
Perhaps a more natural loop would be
void visit_type_FOOList(Visitor *v, const char *name, FOOList **obj, Error
**errp)
{
Error *err = NULL;
GenericList *tail;
size_t size = sizeof(**obj);
visit_start_list(v, name, (GenericList **)obj, size, &err);
if (err) {
goto out;
}
while ((tail = visit_next_list(v, tail, size))) {
visit_type_FOO(v, NULL, &((FOOList *)tail)->value, &err);
if (err) {
break;
}
}
if (visit_end_list(v) && err) {
qapi_free_FOOList(*obj);
*obj = NULL;
}
out:
error_propagate(errp, err);
}
Might also permit de-duplicating the g_malloc0(size), since we now call
next_list() *before* each iteration instead of *between* iterations.
> ---
> v14: no change
> v13: no change
> v12: new patch
> ---
> qapi/qmp-input-visitor.c | 40 +++++++++++++++++++++-------------------
> 1 file changed, 21 insertions(+), 19 deletions(-)
>
> diff --git a/qapi/qmp-input-visitor.c b/qapi/qmp-input-visitor.c
> index cfaf378..1820360 100644
> --- a/qapi/qmp-input-visitor.c
> +++ b/qapi/qmp-input-visitor.c
> @@ -27,9 +27,10 @@ typedef struct StackObject
> {
> QObject *obj; /* Object being visited */
>
> - /* If obj is list: NULL if list is at head, otherwise tail of list
> - * still needing visits */
> + /* If obj is list: tail of list still needing visits */
> const QListEntry *entry;
> + /* If obj is list: true if head is not visited yet */
> + bool first;
Temporary, PATCH 18 will get rid of it. Good, because the less state,
the happier I am :)
>
> GHashTable *h; /* If obj is dict: remaining keys needing visits */
> } StackObject;
> @@ -77,7 +78,12 @@ static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
/* If we are in the middle of a list, then return the next element
> * of the list. */
> if (tos->entry) {
Before the patch, the condition matches the comment: tos->entry implies
this is a list and we're not at its head.
After the patch, the condition only implies it's a list, but ...
> assert(qobject_type(qobj) == QTYPE_QLIST);
> - return qlist_entry_obj(tos->entry);
> + assert(!tos->first);
... you assert that "not at its head" can't happen. Why is that the
case?
> + qobj = qlist_entry_obj(tos->entry);
> + if (consume) {
> + tos->entry = qlist_next(tos->entry);
> + }
> + return qobj;
The remainder of the hunk adds the qlist_next() call moved from
qmp_input_next_list(), as advertized by the commit message. Good.
> }
>
> /* Otherwise, we are at the root of the visit or the start of a
> @@ -91,7 +97,8 @@ static void qdict_add_key(const char *key, QObject *obj,
> void *opaque)
> g_hash_table_insert(h, (gpointer) key, NULL);
> }
>
> -static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
> +static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj,
> + const QListEntry *entry, Error **errp)
> {
> GHashTable *h;
> StackObject *tos = &qiv->stack[qiv->nb_stack];
> @@ -103,7 +110,8 @@ static void qmp_input_push(QmpInputVisitor *qiv, QObject
> *obj, Error **errp)
> }
>
> tos->obj = obj;
> - tos->entry = NULL;
> + tos->entry = entry;
> + tos->first = true;
> tos->h = NULL;
>
> if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
Here, you change the initial state. Not explicitly advertized in the
commit message, unlike the change to qlist_next(). I guess that's okay,
but perhaps my ramblings give you ideas on improving the commit message.
I wonder whether we really need the new argument. Could we do something
like
if (qobject_type(obj) == QTYPE_QLIST) {
tos->entry = qlist_first(qobject_to_qlist(obj));
tos->first = true;
}
?
> @@ -153,7 +161,7 @@ static void qmp_input_start_struct(Visitor *v, const char
> *name, void **obj,
> return;
> }
>
> - qmp_input_push(qiv, qobj, &err);
> + qmp_input_push(qiv, qobj, NULL, &err);
Since @qobj is a dictionary, the StackObject's entry will be unused, so
pass null. Okay.
> if (err) {
> error_propagate(errp, err);
> return;
> @@ -175,6 +183,7 @@ static void qmp_input_start_list(Visitor *v, const char
> *name, Error **errp)
> {
> QmpInputVisitor *qiv = to_qiv(v);
> QObject *qobj = qmp_input_get_object(qiv, name, true);
> + const QListEntry *entry;
>
> if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
> error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
> @@ -182,7 +191,8 @@ static void qmp_input_start_list(Visitor *v, const char
> *name, Error **errp)
> return;
> }
>
> - qmp_input_push(qiv, qobj, errp);
> + entry = qlist_first(qobject_to_qlist(qobj));
> + qmp_input_push(qiv, qobj, entry, errp);
@qobj is a list, the StackObject's entry must be initialized to its
first member, so pass that.
> }
>
> static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
> @@ -191,23 +201,15 @@ static GenericList *qmp_input_next_list(Visitor *v,
> GenericList **list,
> QmpInputVisitor *qiv = to_qiv(v);
> GenericList *entry;
> StackObject *so = &qiv->stack[qiv->nb_stack - 1];
> - bool first;
>
> - if (so->entry == NULL) {
> - so->entry = qlist_first(qobject_to_qlist(so->obj));
> - first = true;
> - } else {
> - so->entry = qlist_next(so->entry);
> - first = false;
> - }
> -
> - if (so->entry == NULL) {
> + if (!so->entry) {
> return NULL;
> }
>
> entry = g_malloc0(size);
> - if (first) {
> + if (so->first) {
> *list = entry;
> + so->first = false;
> } else {
> (*list)->next = entry;
> }
Here, you drop the qlist_next() call. It moves to
qmp_input_get_object(). Good.
> @@ -382,7 +384,7 @@ QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
> v->visitor.type_any = qmp_input_type_any;
> v->visitor.optional = qmp_input_optional;
>
> - qmp_input_push(v, obj, NULL);
> + qmp_input_push(v, obj, NULL, NULL);
@obj is the root of the visit. Can it be a list?
If yes, then StackObject's entry is not its first element. Why is that
correct?
> qobject_incref(obj);
>
> return v;
