[mirror_qemu.git] / qapi / string-output-visitor.c

/*
 * String printing Visitor
 *
 * Copyright Red Hat, Inc. 2012-2016
 *
 * Author: Paolo Bonzini <pbonzini@redhat.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include "qemu/osdep.h"
#include "qemu/cutils.h"
#include "qapi/string-output-visitor.h"
#include "qapi/visitor-impl.h"
#include <math.h>
#include "qemu/range.h"

enum ListMode {
    LM_NONE,             /* not traversing a list of repeated options */
    LM_STARTED,          /* next_list() ready to be called */

    LM_IN_PROGRESS,      /* next_list() has been called.
                          *
                          * Generating the next list link will consume the most
                          * recently parsed QemuOpt instance of the repeated
                          * option.
                          *
                          * Parsing a value into the list link will examine the
                          * next QemuOpt instance of the repeated option, and
                          * possibly enter LM_SIGNED_INTERVAL or
                          * LM_UNSIGNED_INTERVAL.
                          */

    LM_SIGNED_INTERVAL,  /* next_list() has been called.
                          *
                          * Generating the next list link will consume the most
                          * recently stored element from the signed interval,
                          * parsed from the most recent QemuOpt instance of the
                          * repeated option. This may consume QemuOpt itself
                          * and return to LM_IN_PROGRESS.
                          *
                          * Parsing a value into the list link will store the
                          * next element of the signed interval.
                          */

    LM_UNSIGNED_INTERVAL,/* Same as above, only for an unsigned interval. */

    LM_END,              /* next_list() called, about to see last element. */
};

typedef enum ListMode ListMode;

struct StringOutputVisitor
{
    Visitor visitor;
    bool human;
    GString *string;
    char **result;
    ListMode list_mode;
    union {
        int64_t s;
        uint64_t u;
    } range_start, range_end;
    GList *ranges;
    void *list; /* Only needed for sanity checking the caller */
    unsigned int struct_nesting;
};

static StringOutputVisitor *to_sov(Visitor *v)
{
    return container_of(v, StringOutputVisitor, visitor);
}

static void string_output_set(StringOutputVisitor *sov, char *string)
{
    switch (sov->list_mode) {
    case LM_STARTED:
        sov->list_mode = LM_IN_PROGRESS;
        /* fall through */
    case LM_NONE:
        if (sov->string) {
            g_string_free(sov->string, true);
        }
        sov->string = g_string_new(string);
        g_free(string);
        break;

    case LM_IN_PROGRESS:
    case LM_END:
        g_string_append(sov->string, ", ");
        g_string_append(sov->string, string);
        break;

    default:
        abort();
    }
}

static void string_output_append(StringOutputVisitor *sov, int64_t a)
{
    Range *r = g_malloc0(sizeof(*r));

    range_set_bounds(r, a, a);
    sov->ranges = range_list_insert(sov->ranges, r);
}

static void string_output_append_range(StringOutputVisitor *sov,
                                       int64_t s, int64_t e)
{
    Range *r = g_malloc0(sizeof(*r));

    range_set_bounds(r, s, e);
    sov->ranges = range_list_insert(sov->ranges, r);
}

static void format_string(StringOutputVisitor *sov, Range *r, bool next,
                          bool human)
{
    if (range_lob(r) != range_upb(r)) {
        if (human) {
            g_string_append_printf(sov->string, "0x%" PRIx64 "-0x%" PRIx64,
                                   range_lob(r), range_upb(r));

        } else {
            g_string_append_printf(sov->string, "%" PRId64 "-%" PRId64,
                                   range_lob(r), range_upb(r));
        }
    } else {
        if (human) {
            g_string_append_printf(sov->string, "0x%" PRIx64, range_lob(r));
        } else {
            g_string_append_printf(sov->string, "%" PRId64, range_lob(r));
        }
    }
    if (next) {
        g_string_append(sov->string, ",");
    }
}

static bool print_type_int64(Visitor *v, const char *name, int64_t *obj,
                             Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);
    GList *l;

    if (sov->struct_nesting) {
        return true;
    }

    switch (sov->list_mode) {
    case LM_NONE:
        string_output_append(sov, *obj);
        break;

    case LM_STARTED:
        sov->range_start.s = *obj;
        sov->range_end.s = *obj;
        sov->list_mode = LM_IN_PROGRESS;
        return true;

    case LM_IN_PROGRESS:
        if (sov->range_end.s + 1 == *obj) {
            sov->range_end.s++;
        } else {
            if (sov->range_start.s == sov->range_end.s) {
                string_output_append(sov, sov->range_end.s);
            } else {
                assert(sov->range_start.s < sov->range_end.s);
                string_output_append_range(sov, sov->range_start.s,
                                           sov->range_end.s);
            }

            sov->range_start.s = *obj;
            sov->range_end.s = *obj;
        }
        return true;

    case LM_END:
        if (sov->range_end.s + 1 == *obj) {
            sov->range_end.s++;
            assert(sov->range_start.s < sov->range_end.s);
            string_output_append_range(sov, sov->range_start.s,
                                       sov->range_end.s);
        } else {
            if (sov->range_start.s == sov->range_end.s) {
                string_output_append(sov, sov->range_end.s);
            } else {
                assert(sov->range_start.s < sov->range_end.s);

                string_output_append_range(sov, sov->range_start.s,
                                           sov->range_end.s);
            }
            string_output_append(sov, *obj);
        }
        break;

    default:
        abort();
    }

    l = sov->ranges;
    while (l) {
        Range *r = l->data;
        format_string(sov, r, l->next != NULL, false);
        l = l->next;
    }

    if (sov->human) {
        l = sov->ranges;
        g_string_append(sov->string, " (");
        while (l) {
            Range *r = l->data;
            format_string(sov, r, l->next != NULL, true);
            l = l->next;
        }
        g_string_append(sov->string, ")");
    }

    return true;
}

static bool print_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                             Error **errp)
{
    /* FIXME: print_type_int64 mishandles values over INT64_MAX */
    int64_t i = *obj;
    return print_type_int64(v, name, &i, errp);
}

static bool print_type_size(Visitor *v, const char *name, uint64_t *obj,
                            Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);
    uint64_t val;
    char *out, *psize;

    if (sov->struct_nesting) {
        return true;
    }

    if (!sov->human) {
        out = g_strdup_printf("%"PRIu64, *obj);
        string_output_set(sov, out);
        return true;
    }

    val = *obj;
    psize = size_to_str(val);
    out = g_strdup_printf("%"PRIu64" (%s)", val, psize);
    string_output_set(sov, out);

    g_free(psize);
    return true;
}

static bool print_type_bool(Visitor *v, const char *name, bool *obj,
                            Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);

    if (sov->struct_nesting) {
        return true;
    }

    string_output_set(sov, g_strdup(*obj ? "true" : "false"));
    return true;
}

static bool print_type_str(Visitor *v, const char *name, char **obj,
                           Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);
    char *out;

    if (sov->struct_nesting) {
        return true;
    }

    if (sov->human) {
        out = *obj ? g_strdup_printf("\"%s\"", *obj) : g_strdup("<null>");
    } else {
        out = g_strdup(*obj ? *obj : "");
    }
    string_output_set(sov, out);
    return true;
}

static bool print_type_number(Visitor *v, const char *name, double *obj,
                              Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);

    if (sov->struct_nesting) {
        return true;
    }

    string_output_set(sov, g_strdup_printf("%.17g", *obj));
    return true;
}

static bool print_type_null(Visitor *v, const char *name, QNull **obj,
                            Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);
    char *out;

    if (sov->struct_nesting) {
        return true;
    }

    if (sov->human) {
        out = g_strdup("<null>");
    } else {
        out = g_strdup("");
    }
    string_output_set(sov, out);
    return true;
}

static bool start_struct(Visitor *v, const char *name, void **obj,
                         size_t size, Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);

    sov->struct_nesting++;
    return true;
}

static void end_struct(Visitor *v, void **obj)
{
    StringOutputVisitor *sov = to_sov(v);

    if (--sov->struct_nesting) {
        return;
    }

    /* TODO actually print struct fields */
    string_output_set(sov, g_strdup("<omitted>"));
}

static bool
start_list(Visitor *v, const char *name, GenericList **list, size_t size,
           Error **errp)
{
    StringOutputVisitor *sov = to_sov(v);

    if (sov->struct_nesting) {
        return true;
    }

    /* we can't traverse a list in a list */
    assert(sov->list_mode == LM_NONE);
    /* We don't support visits without a list */
    assert(list);
    sov->list = list;
    /* List handling is only needed if there are at least two elements */
    if (*list && (*list)->next) {
        sov->list_mode = LM_STARTED;
    }
    return true;
}

static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
{
    StringOutputVisitor *sov = to_sov(v);
    GenericList *ret = tail->next;

    if (sov->struct_nesting) {
        return ret;
    }

    if (ret && !ret->next) {
        sov->list_mode = LM_END;
    }
    return ret;
}

static void end_list(Visitor *v, void **obj)
{
    StringOutputVisitor *sov = to_sov(v);

    if (sov->struct_nesting) {
        return;
    }

    assert(sov->list == obj);
    assert(sov->list_mode == LM_STARTED ||
           sov->list_mode == LM_END ||
           sov->list_mode == LM_NONE ||
           sov->list_mode == LM_IN_PROGRESS);
    sov->list_mode = LM_NONE;
}

static void string_output_complete(Visitor *v, void *opaque)
{
    StringOutputVisitor *sov = to_sov(v);

    assert(opaque == sov->result);
    *sov->result = g_string_free(sov->string, false);
    sov->string = NULL;
}

static void free_range(void *range, void *dummy)
{
    g_free(range);
}

static void string_output_free(Visitor *v)
{
    StringOutputVisitor *sov = to_sov(v);

    if (sov->string) {
        g_string_free(sov->string, true);
    }

    g_list_foreach(sov->ranges, free_range, NULL);
    g_list_free(sov->ranges);
    g_free(sov);
}

Visitor *string_output_visitor_new(bool human, char **result)
{
    StringOutputVisitor *v;

    v = g_malloc0(sizeof(*v));

    v->string = g_string_new(NULL);
    v->human = human;
    v->result = result;
    *result = NULL;

    v->visitor.type = VISITOR_OUTPUT;
    v->visitor.type_int64 = print_type_int64;
    v->visitor.type_uint64 = print_type_uint64;
    v->visitor.type_size = print_type_size;
    v->visitor.type_bool = print_type_bool;
    v->visitor.type_str = print_type_str;
    v->visitor.type_number = print_type_number;
    v->visitor.type_null = print_type_null;
    v->visitor.start_struct = start_struct;
    v->visitor.end_struct = end_struct;
    v->visitor.start_list = start_list;
    v->visitor.next_list = next_list;
    v->visitor.end_list = end_list;
    v->visitor.complete = string_output_complete;
    v->visitor.free = string_output_free;

    return &v->visitor;
}
Commit	Line	Data
a020f980 PB	1	/*
	2	* String printing Visitor
	3	*
08f9541d	4	* Copyright Red Hat, Inc. 2012-2016
a020f980 PB	5	*
	6	* Author: Paolo Bonzini <pbonzini@redhat.com>
	7	*
	8	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	9	* See the COPYING.LIB file in the top-level directory.
	10	*
	11	*/
	12
cbf21151	13	#include "qemu/osdep.h"
31e40415	14	#include "qemu/cutils.h"
7b1b5d19 PB	15	#include "qapi/string-output-visitor.h"
7b1b5d19 PB	16	#include "qapi/visitor-impl.h"
e41b509d	17	#include <math.h>
69e25563 HT	18	#include "qemu/range.h"
	19
	20	enum ListMode {
	21	LM_NONE, /* not traversing a list of repeated options */
d9f62dde	22	LM_STARTED, /* next_list() ready to be called */
69e25563 HT	23
	24	LM_IN_PROGRESS, /* next_list() has been called.
	25	*
	26	* Generating the next list link will consume the most
	27	* recently parsed QemuOpt instance of the repeated
	28	* option.
	29	*
	30	* Parsing a value into the list link will examine the
	31	* next QemuOpt instance of the repeated option, and
	32	* possibly enter LM_SIGNED_INTERVAL or
	33	* LM_UNSIGNED_INTERVAL.
	34	*/
	35
	36	LM_SIGNED_INTERVAL, /* next_list() has been called.
	37	*
	38	* Generating the next list link will consume the most
	39	* recently stored element from the signed interval,
	40	* parsed from the most recent QemuOpt instance of the
	41	* repeated option. This may consume QemuOpt itself
	42	* and return to LM_IN_PROGRESS.
	43	*
	44	* Parsing a value into the list link will store the
	45	* next element of the signed interval.
	46	*/
	47
	48	LM_UNSIGNED_INTERVAL,/* Same as above, only for an unsigned interval. */
	49
d9f62dde	50	LM_END, /* next_list() called, about to see last element. */
69e25563 HT	51	};
	52
	53	typedef enum ListMode ListMode;
a020f980 PB	54
	55	struct StringOutputVisitor
	56	{
	57	Visitor visitor;
0b7593e0	58	bool human;
69e25563	59	GString *string;
3b098d56	60	char **result;
69e25563 HT	61	ListMode list_mode;
	62	union {
	63	int64_t s;
	64	uint64_t u;
	65	} range_start, range_end;
	66	GList *ranges;
1158bb2a	67	void list; / Only needed for sanity checking the caller */
014b99a8	68	unsigned int struct_nesting;
a020f980 PB	69	};
a020f980 PB	70
d7bea75d EB	71	static StringOutputVisitor to_sov(Visitor v)
	72	{
	73	return container_of(v, StringOutputVisitor, visitor);
	74	}
	75
a020f980 PB	76	static void string_output_set(StringOutputVisitor sov, char string)
a020f980 PB	77	{
ea7ec158 KW	78	switch (sov->list_mode) {
	79	case LM_STARTED:
	80	sov->list_mode = LM_IN_PROGRESS;
	81	/* fall through */
	82	case LM_NONE:
	83	if (sov->string) {
	84	g_string_free(sov->string, true);
	85	}
	86	sov->string = g_string_new(string);
	87	g_free(string);
	88	break;
	89
	90	case LM_IN_PROGRESS:
	91	case LM_END:
	92	g_string_append(sov->string, ", ");
	93	g_string_append(sov->string, string);
	94	break;
	95
	96	default:
	97	abort();
69e25563	98	}
69e25563 HT	99	}
	100
	101	static void string_output_append(StringOutputVisitor *sov, int64_t a)
	102	{
	103	Range r = g_malloc0(sizeof(r));
a0efbf16 MA	104
a0efbf16 MA	105	range_set_bounds(r, a, a);
7c47959d	106	sov->ranges = range_list_insert(sov->ranges, r);
69e25563 HT	107	}
	108
	109	static void string_output_append_range(StringOutputVisitor *sov,
	110	int64_t s, int64_t e)
	111	{
	112	Range r = g_malloc0(sizeof(r));
a0efbf16 MA	113
a0efbf16 MA	114	range_set_bounds(r, s, e);
7c47959d	115	sov->ranges = range_list_insert(sov->ranges, r);
69e25563 HT	116	}
	117
	118	static void format_string(StringOutputVisitor sov, Range r, bool next,
	119	bool human)
	120	{
a0efbf16	121	if (range_lob(r) != range_upb(r)) {
69e25563	122	if (human) {
684531ad	123	g_string_append_printf(sov->string, "0x%" PRIx64 "-0x%" PRIx64,
a0efbf16	124	range_lob(r), range_upb(r));
69e25563 HT	125
	126	} else {
	127	g_string_append_printf(sov->string, "%" PRId64 "-%" PRId64,
a0efbf16	128	range_lob(r), range_upb(r));
69e25563 HT	129	}
	130	} else {
	131	if (human) {
a0efbf16	132	g_string_append_printf(sov->string, "0x%" PRIx64, range_lob(r));
69e25563	133	} else {
a0efbf16	134	g_string_append_printf(sov->string, "%" PRId64, range_lob(r));
69e25563 HT	135	}
	136	}
	137	if (next) {
	138	g_string_append(sov->string, ",");
	139	}
a020f980 PB	140	}
a020f980 PB	141
012d4c96	142	static bool print_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	143	Error **errp)
a020f980	144	{
d7bea75d	145	StringOutputVisitor *sov = to_sov(v);
69e25563 HT	146	GList *l;
69e25563 HT	147
014b99a8 KW	148	if (sov->struct_nesting) {
	149	return true;
	150	}
	151
69e25563 HT	152	switch (sov->list_mode) {
	153	case LM_NONE:
	154	string_output_append(sov, *obj);
	155	break;
	156
	157	case LM_STARTED:
	158	sov->range_start.s = *obj;
	159	sov->range_end.s = *obj;
	160	sov->list_mode = LM_IN_PROGRESS;
012d4c96	161	return true;
69e25563 HT	162
	163	case LM_IN_PROGRESS:
	164	if (sov->range_end.s + 1 == *obj) {
	165	sov->range_end.s++;
	166	} else {
	167	if (sov->range_start.s == sov->range_end.s) {
	168	string_output_append(sov, sov->range_end.s);
	169	} else {
	170	assert(sov->range_start.s < sov->range_end.s);
	171	string_output_append_range(sov, sov->range_start.s,
	172	sov->range_end.s);
	173	}
	174
	175	sov->range_start.s = *obj;
	176	sov->range_end.s = *obj;
	177	}
012d4c96	178	return true;
69e25563 HT	179
	180	case LM_END:
	181	if (sov->range_end.s + 1 == *obj) {
	182	sov->range_end.s++;
	183	assert(sov->range_start.s < sov->range_end.s);
	184	string_output_append_range(sov, sov->range_start.s,
	185	sov->range_end.s);
	186	} else {
	187	if (sov->range_start.s == sov->range_end.s) {
	188	string_output_append(sov, sov->range_end.s);
	189	} else {
	190	assert(sov->range_start.s < sov->range_end.s);
	191
	192	string_output_append_range(sov, sov->range_start.s,
	193	sov->range_end.s);
	194	}
	195	string_output_append(sov, *obj);
	196	}
	197	break;
	198
	199	default:
	200	abort();
	201	}
	202
	203	l = sov->ranges;
	204	while (l) {
	205	Range *r = l->data;
	206	format_string(sov, r, l->next != NULL, false);
	207	l = l->next;
	208	}
0b7593e0 PB	209
0b7593e0 PB	210	if (sov->human) {
69e25563 HT	211	l = sov->ranges;
	212	g_string_append(sov->string, " (");
	213	while (l) {
	214	Range *r = l->data;
56fdfb61	215	format_string(sov, r, l->next != NULL, true);
69e25563 HT	216	l = l->next;
	217	}
	218	g_string_append(sov->string, ")");
0b7593e0	219	}
012d4c96 MA	220
012d4c96 MA	221	return true;
0b7593e0 PB	222	}
0b7593e0 PB	223
012d4c96	224	static bool print_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	225	Error **errp)
	226	{
	227	/* FIXME: print_type_int64 mishandles values over INT64_MAX */
	228	int64_t i = *obj;
012d4c96	229	return print_type_int64(v, name, &i, errp);
f755dea7 EB	230	}
f755dea7 EB	231
012d4c96	232	static bool print_type_size(Visitor v, const char name, uint64_t *obj,
0b2a0d6b	233	Error **errp)
0b7593e0	234	{
d7bea75d	235	StringOutputVisitor *sov = to_sov(v);
22951aaa PX	236	uint64_t val;
22951aaa PX	237	char out, psize;
0b7593e0	238
014b99a8 KW	239	if (sov->struct_nesting) {
	240	return true;
	241	}
	242
0b7593e0	243	if (!sov->human) {
e41b509d	244	out = g_strdup_printf("%"PRIu64, *obj);
0b7593e0	245	string_output_set(sov, out);
012d4c96	246	return true;
0b7593e0 PB	247	}
	248
	249	val = *obj;
22951aaa PX	250	psize = size_to_str(val);
22951aaa PX	251	out = g_strdup_printf("%"PRIu64" (%s)", val, psize);
0b7593e0	252	string_output_set(sov, out);
22951aaa PX	253
22951aaa PX	254	g_free(psize);
012d4c96	255	return true;
a020f980 PB	256	}
a020f980 PB	257
012d4c96	258	static bool print_type_bool(Visitor v, const char name, bool *obj,
a020f980 PB	259	Error **errp)
a020f980 PB	260	{
d7bea75d	261	StringOutputVisitor *sov = to_sov(v);
014b99a8 KW	262
	263	if (sov->struct_nesting) {
	264	return true;
	265	}
	266
a020f980	267	string_output_set(sov, g_strdup(*obj ? "true" : "false"));
012d4c96	268	return true;
a020f980 PB	269	}
a020f980 PB	270
012d4c96	271	static bool print_type_str(Visitor v, const char name, char **obj,
a020f980 PB	272	Error **errp)
a020f980 PB	273	{
d7bea75d	274	StringOutputVisitor *sov = to_sov(v);
0b7593e0 PB	275	char *out;
0b7593e0 PB	276
014b99a8 KW	277	if (sov->struct_nesting) {
	278	return true;
	279	}
	280
0b7593e0 PB	281	if (sov->human) {
	282	out = obj ? g_strdup_printf("\"%s\"", obj) : g_strdup("<null>");
	283	} else {
	284	out = g_strdup(obj ? obj : "");
	285	}
	286	string_output_set(sov, out);
012d4c96	287	return true;
a020f980 PB	288	}
a020f980 PB	289
012d4c96	290	static bool print_type_number(Visitor v, const char name, double *obj,
a020f980 PB	291	Error **errp)
a020f980 PB	292	{
d7bea75d	293	StringOutputVisitor *sov = to_sov(v);
014b99a8 KW	294
	295	if (sov->struct_nesting) {
	296	return true;
	297	}
	298
54addb01	299	string_output_set(sov, g_strdup_printf("%.17g", *obj));
012d4c96	300	return true;
a020f980 PB	301	}
a020f980 PB	302
012d4c96	303	static bool print_type_null(Visitor v, const char name, QNull **obj,
d2f95f4d	304	Error **errp)
a7333712 GK	305	{
	306	StringOutputVisitor *sov = to_sov(v);
	307	char *out;
	308
014b99a8 KW	309	if (sov->struct_nesting) {
	310	return true;
	311	}
	312
a7333712 GK	313	if (sov->human) {
	314	out = g_strdup("<null>");
	315	} else {
	316	out = g_strdup("");
	317	}
	318	string_output_set(sov, out);
012d4c96	319	return true;
a7333712 GK	320	}
a7333712 GK	321
ff32bb53 SH	322	static bool start_struct(Visitor v, const char name, void **obj,
	323	size_t size, Error **errp)
	324	{
014b99a8 KW	325	StringOutputVisitor *sov = to_sov(v);
	326
	327	sov->struct_nesting++;
ff32bb53 SH	328	return true;
	329	}
	330
	331	static void end_struct(Visitor v, void *obj)
	332	{
	333	StringOutputVisitor *sov = to_sov(v);
	334
014b99a8 KW	335	if (--sov->struct_nesting) {
	336	return;
	337	}
	338
ff32bb53 SH	339	/* TODO actually print struct fields */
	340	string_output_set(sov, g_strdup("<omitted>"));
	341	}
	342
012d4c96	343	static bool
d9f62dde EB	344	start_list(Visitor v, const char name, GenericList **list, size_t size,
d9f62dde EB	345	Error **errp)
69e25563	346	{
d7bea75d	347	StringOutputVisitor *sov = to_sov(v);
69e25563	348
014b99a8 KW	349	if (sov->struct_nesting) {
	350	return true;
	351	}
	352
69e25563 HT	353	/* we can't traverse a list in a list */
69e25563 HT	354	assert(sov->list_mode == LM_NONE);
d9f62dde EB	355	/* We don't support visits without a list */
d9f62dde EB	356	assert(list);
1158bb2a	357	sov->list = list;
d9f62dde EB	358	/* List handling is only needed if there are at least two elements */
	359	if (list && (list)->next) {
	360	sov->list_mode = LM_STARTED;
	361	}
012d4c96	362	return true;
69e25563 HT	363	}
69e25563 HT	364
d9f62dde	365	static GenericList next_list(Visitor v, GenericList *tail, size_t size)
69e25563	366	{
d7bea75d	367	StringOutputVisitor *sov = to_sov(v);
d9f62dde	368	GenericList *ret = tail->next;
69e25563	369
014b99a8 KW	370	if (sov->struct_nesting) {
	371	return ret;
	372	}
	373
d9f62dde EB	374	if (ret && !ret->next) {
d9f62dde EB	375	sov->list_mode = LM_END;
69e25563	376	}
69e25563 HT	377	return ret;
	378	}
	379
1158bb2a	380	static void end_list(Visitor v, void *obj)
69e25563	381	{
d7bea75d	382	StringOutputVisitor *sov = to_sov(v);
69e25563	383
014b99a8 KW	384	if (sov->struct_nesting) {
	385	return;
	386	}
	387
1158bb2a	388	assert(sov->list == obj);
69e25563 HT	389	assert(sov->list_mode == LM_STARTED \|\|
	390	sov->list_mode == LM_END \|\|
	391	sov->list_mode == LM_NONE \|\|
	392	sov->list_mode == LM_IN_PROGRESS);
	393	sov->list_mode = LM_NONE;
69e25563 HT	394	}
69e25563 HT	395
3b098d56	396	static void string_output_complete(Visitor v, void opaque)
a020f980	397	{
3b098d56	398	StringOutputVisitor *sov = to_sov(v);
a020f980	399
3b098d56 EB	400	assert(opaque == sov->result);
	401	*sov->result = g_string_free(sov->string, false);
	402	sov->string = NULL;
a020f980 PB	403	}
a020f980 PB	404
0d156683 MT	405	static void free_range(void range, void dummy)
	406	{
	407	g_free(range);
	408	}
	409
2c0ef9f4 EB	410	static void string_output_free(Visitor *v)
	411	{
	412	StringOutputVisitor *sov = to_sov(v);
	413
69e25563 HT	414	if (sov->string) {
	415	g_string_free(sov->string, true);
	416	}
	417
0d156683 MT	418	g_list_foreach(sov->ranges, free_range, NULL);
0d156683 MT	419	g_list_free(sov->ranges);
a020f980 PB	420	g_free(sov);
	421	}
	422
3b098d56	423	Visitor string_output_visitor_new(bool human, char *result)
a020f980 PB	424	{
	425	StringOutputVisitor *v;
	426
	427	v = g_malloc0(sizeof(*v));
	428
69e25563	429	v->string = g_string_new(NULL);
0b7593e0	430	v->human = human;
3b098d56 EB	431	v->result = result;
	432	*result = NULL;
	433
983f52d4	434	v->visitor.type = VISITOR_OUTPUT;
4c40314a	435	v->visitor.type_int64 = print_type_int64;
f755dea7	436	v->visitor.type_uint64 = print_type_uint64;
0b7593e0	437	v->visitor.type_size = print_type_size;
a020f980 PB	438	v->visitor.type_bool = print_type_bool;
	439	v->visitor.type_str = print_type_str;
	440	v->visitor.type_number = print_type_number;
a7333712	441	v->visitor.type_null = print_type_null;
ff32bb53 SH	442	v->visitor.start_struct = start_struct;
ff32bb53 SH	443	v->visitor.end_struct = end_struct;
69e25563 HT	444	v->visitor.start_list = start_list;
	445	v->visitor.next_list = next_list;
	446	v->visitor.end_list = end_list;
3b098d56	447	v->visitor.complete = string_output_complete;
2c0ef9f4	448	v->visitor.free = string_output_free;
a020f980	449
3b098d56	450	return &v->visitor;
a020f980	451	}