[mirror_qemu.git] / qapi / qapi-visit-core.c

/*
 * Core Definitions for QAPI Visitor Classes
 *
 * Copyright (C) 2012-2016 Red Hat, Inc.
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "qapi/qmp/qobject.h"
#include "qapi/qmp/qerror.h"
#include "qapi/visitor.h"
#include "qapi/visitor-impl.h"

void visit_complete(Visitor *v, void *opaque)
{
    assert(v->type != VISITOR_OUTPUT || v->complete);
    if (v->complete) {
        v->complete(v, opaque);
    }
}

void visit_free(Visitor *v)
{
    if (v) {
        v->free(v);
    }
}

void visit_start_struct(Visitor *v, const char *name, void **obj,
                        size_t size, Error **errp)
{
    Error *err = NULL;

    if (obj) {
        assert(size);
        assert(v->type != VISITOR_OUTPUT || *obj);
    }
    v->start_struct(v, name, obj, size, &err);
    if (obj && v->type == VISITOR_INPUT) {
        assert(!err != !*obj);
    }
    error_propagate(errp, err);
}

void visit_check_struct(Visitor *v, Error **errp)
{
    if (v->check_struct) {
        v->check_struct(v, errp);
    }
}

void visit_end_struct(Visitor *v, void **obj)
{
    v->end_struct(v, obj);
}

void visit_start_list(Visitor *v, const char *name, GenericList **list,
                      size_t size, Error **errp)
{
    Error *err = NULL;

    assert(!list || size >= sizeof(GenericList));
    v->start_list(v, name, list, size, &err);
    if (list && v->type == VISITOR_INPUT) {
        assert(!(err && *list));
    }
    error_propagate(errp, err);
}

GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
{
    assert(tail && size >= sizeof(GenericList));
    return v->next_list(v, tail, size);
}

void visit_end_list(Visitor *v, void **obj)
{
    v->end_list(v, obj);
}

void visit_start_alternate(Visitor *v, const char *name,
                           GenericAlternate **obj, size_t size,
                           bool promote_int, Error **errp)
{
    Error *err = NULL;

    assert(obj && size >= sizeof(GenericAlternate));
    assert(v->type != VISITOR_OUTPUT || *obj);
    if (v->start_alternate) {
        v->start_alternate(v, name, obj, size, promote_int, &err);
    }
    if (v->type == VISITOR_INPUT) {
        assert(v->start_alternate && !err != !*obj);
    }
    error_propagate(errp, err);
}

void visit_end_alternate(Visitor *v, void **obj)
{
    if (v->end_alternate) {
        v->end_alternate(v, obj);
    }
}

bool visit_optional(Visitor *v, const char *name, bool *present)
{
    if (v->optional) {
        v->optional(v, name, present);
    }
    return *present;
}

bool visit_is_input(Visitor *v)
{
    return v->type == VISITOR_INPUT;
}

void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
{
    assert(obj);
    v->type_int64(v, name, obj, errp);
}

static void visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
                             uint64_t max, const char *type, Error **errp)
{
    Error *err = NULL;
    uint64_t value = *obj;

    v->type_uint64(v, name, &value, &err);
    if (err) {
        error_propagate(errp, err);
    } else if (value > max) {
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
                   name ? name : "null", type);
    } else {
        *obj = value;
    }
}

void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
                      Error **errp)
{
    uint64_t value = *obj;
    visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
    *obj = value;
}

void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
                       Error **errp)
{
    uint64_t value = *obj;
    visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
    *obj = value;
}

void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
                       Error **errp)
{
    uint64_t value = *obj;
    visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
    *obj = value;
}

void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                       Error **errp)
{
    assert(obj);
    v->type_uint64(v, name, obj, errp);
}

static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
                            int64_t min, int64_t max, const char *type,
                            Error **errp)
{
    Error *err = NULL;
    int64_t value = *obj;

    v->type_int64(v, name, &value, &err);
    if (err) {
        error_propagate(errp, err);
    } else if (value < min || value > max) {
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
                   name ? name : "null", type);
    } else {
        *obj = value;
    }
}

void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
{
    int64_t value = *obj;
    visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
    *obj = value;
}

void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
                      Error **errp)
{
    int64_t value = *obj;
    visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
    *obj = value;
}

void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
                      Error **errp)
{
    int64_t value = *obj;
    visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
    *obj = value;
}

void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
                      Error **errp)
{
    assert(obj);
    v->type_int64(v, name, obj, errp);
}

void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
                     Error **errp)
{
    assert(obj);
    if (v->type_size) {
        v->type_size(v, name, obj, errp);
    } else {
        v->type_uint64(v, name, obj, errp);
    }
}

void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
{
    assert(obj);
    v->type_bool(v, name, obj, errp);
}

void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
{
    Error *err = NULL;

    assert(obj);
    /* TODO: Fix callers to not pass NULL when they mean "", so that we
     * can enable:
    assert(v->type != VISITOR_OUTPUT || *obj);
     */
    v->type_str(v, name, obj, &err);
    if (v->type == VISITOR_INPUT) {
        assert(!err != !*obj);
    }
    error_propagate(errp, err);
}

void visit_type_number(Visitor *v, const char *name, double *obj,
                       Error **errp)
{
    assert(obj);
    v->type_number(v, name, obj, errp);
}

void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
{
    Error *err = NULL;

    assert(obj);
    assert(v->type != VISITOR_OUTPUT || *obj);
    v->type_any(v, name, obj, &err);
    if (v->type == VISITOR_INPUT) {
        assert(!err != !*obj);
    }
    error_propagate(errp, err);
}

void visit_type_null(Visitor *v, const char *name, Error **errp)
{
    v->type_null(v, name, errp);
}

static void output_type_enum(Visitor *v, const char *name, int *obj,
                             const char *const strings[], Error **errp)
{
    int i = 0;
    int value = *obj;
    char *enum_str;

    while (strings[i++] != NULL);
    if (value < 0 || value >= i - 1) {
        error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
        return;
    }

    enum_str = (char *)strings[value];
    visit_type_str(v, name, &enum_str, errp);
}

static void input_type_enum(Visitor *v, const char *name, int *obj,
                            const char *const strings[], Error **errp)
{
    Error *local_err = NULL;
    int64_t value = 0;
    char *enum_str;

    visit_type_str(v, name, &enum_str, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }

    while (strings[value] != NULL) {
        if (strcmp(strings[value], enum_str) == 0) {
            break;
        }
        value++;
    }

    if (strings[value] == NULL) {
        error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
        g_free(enum_str);
        return;
    }

    g_free(enum_str);
    *obj = value;
}

void visit_type_enum(Visitor *v, const char *name, int *obj,
                     const char *const strings[], Error **errp)
{
    assert(obj && strings);
    if (v->type == VISITOR_INPUT) {
        input_type_enum(v, name, obj, strings, errp);
    } else if (v->type == VISITOR_OUTPUT) {
        output_type_enum(v, name, obj, strings, errp);
    }
}
Commit	Line	Data
	1	/*
	2	* Core Definitions for QAPI Visitor Classes
	3	*
	4	* Copyright (C) 2012-2016 Red Hat, Inc.
	5	* Copyright IBM, Corp. 2011
	6	*
	7	* Authors:
	8	* Anthony Liguori <aliguori@us.ibm.com>
	9	*
	10	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	11	* See the COPYING.LIB file in the top-level directory.
	12	*
	13	*/
	14
	15	#include "qemu/osdep.h"
	16	#include "qapi/error.h"
	17	#include "qemu-common.h"
	18	#include "qapi/qmp/qobject.h"
	19	#include "qapi/qmp/qerror.h"
	20	#include "qapi/visitor.h"
	21	#include "qapi/visitor-impl.h"
	22
	23	void visit_complete(Visitor v, void opaque)
	24	{
	25	assert(v->type != VISITOR_OUTPUT \|\| v->complete);
	26	if (v->complete) {
	27	v->complete(v, opaque);
	28	}
	29	}
	30
	31	void visit_free(Visitor *v)
	32	{
	33	if (v) {
	34	v->free(v);
	35	}
	36	}
	37
	38	void visit_start_struct(Visitor v, const char name, void **obj,
	39	size_t size, Error **errp)
	40	{
	41	Error *err = NULL;
	42
	43	if (obj) {
	44	assert(size);
	45	assert(v->type != VISITOR_OUTPUT \|\| *obj);
	46	}
	47	v->start_struct(v, name, obj, size, &err);
	48	if (obj && v->type == VISITOR_INPUT) {
	49	assert(!err != !*obj);
	50	}
	51	error_propagate(errp, err);
	52	}
	53
	54	void visit_check_struct(Visitor v, Error *errp)
	55	{
	56	if (v->check_struct) {
	57	v->check_struct(v, errp);
	58	}
	59	}
	60
	61	void visit_end_struct(Visitor v, void *obj)
	62	{
	63	v->end_struct(v, obj);
	64	}
	65
	66	void visit_start_list(Visitor v, const char name, GenericList **list,
	67	size_t size, Error **errp)
	68	{
	69	Error *err = NULL;
	70
	71	assert(!list \|\| size >= sizeof(GenericList));
	72	v->start_list(v, name, list, size, &err);
	73	if (list && v->type == VISITOR_INPUT) {
	74	assert(!(err && *list));
	75	}
	76	error_propagate(errp, err);
	77	}
	78
	79	GenericList visit_next_list(Visitor v, GenericList *tail, size_t size)
	80	{
	81	assert(tail && size >= sizeof(GenericList));
	82	return v->next_list(v, tail, size);
	83	}
	84
	85	void visit_end_list(Visitor v, void *obj)
	86	{
	87	v->end_list(v, obj);
	88	}
	89
	90	void visit_start_alternate(Visitor v, const char name,
	91	GenericAlternate **obj, size_t size,
	92	bool promote_int, Error **errp)
	93	{
	94	Error *err = NULL;
	95
	96	assert(obj && size >= sizeof(GenericAlternate));
	97	assert(v->type != VISITOR_OUTPUT \|\| *obj);
	98	if (v->start_alternate) {
	99	v->start_alternate(v, name, obj, size, promote_int, &err);
	100	}
	101	if (v->type == VISITOR_INPUT) {
	102	assert(v->start_alternate && !err != !*obj);
	103	}
	104	error_propagate(errp, err);
	105	}
	106
	107	void visit_end_alternate(Visitor v, void *obj)
	108	{
	109	if (v->end_alternate) {
	110	v->end_alternate(v, obj);
	111	}
	112	}
	113
	114	bool visit_optional(Visitor v, const char name, bool *present)
	115	{
	116	if (v->optional) {
	117	v->optional(v, name, present);
	118	}
	119	return *present;
	120	}
	121
	122	bool visit_is_input(Visitor *v)
	123	{
	124	return v->type == VISITOR_INPUT;
	125	}
	126
	127	void visit_type_int(Visitor v, const char name, int64_t obj, Error *errp)
	128	{
	129	assert(obj);
	130	v->type_int64(v, name, obj, errp);
	131	}
	132
	133	static void visit_type_uintN(Visitor v, uint64_t obj, const char *name,
	134	uint64_t max, const char type, Error *errp)
	135	{
	136	Error *err = NULL;
	137	uint64_t value = *obj;
	138
	139	v->type_uint64(v, name, &value, &err);
	140	if (err) {
	141	error_propagate(errp, err);
	142	} else if (value > max) {
	143	error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
	144	name ? name : "null", type);
	145	} else {
	146	*obj = value;
	147	}
	148	}
	149
	150	void visit_type_uint8(Visitor v, const char name, uint8_t *obj,
	151	Error **errp)
	152	{
	153	uint64_t value = *obj;
	154	visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
	155	*obj = value;
	156	}
	157
	158	void visit_type_uint16(Visitor v, const char name, uint16_t *obj,
	159	Error **errp)
	160	{
	161	uint64_t value = *obj;
	162	visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
	163	*obj = value;
	164	}
	165
	166	void visit_type_uint32(Visitor v, const char name, uint32_t *obj,
	167	Error **errp)
	168	{
	169	uint64_t value = *obj;
	170	visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
	171	*obj = value;
	172	}
	173
	174	void visit_type_uint64(Visitor v, const char name, uint64_t *obj,
	175	Error **errp)
	176	{
	177	assert(obj);
	178	v->type_uint64(v, name, obj, errp);
	179	}
	180
	181	static void visit_type_intN(Visitor v, int64_t obj, const char *name,
	182	int64_t min, int64_t max, const char *type,
	183	Error **errp)
	184	{
	185	Error *err = NULL;
	186	int64_t value = *obj;
	187
	188	v->type_int64(v, name, &value, &err);
	189	if (err) {
	190	error_propagate(errp, err);
	191	} else if (value < min \|\| value > max) {
	192	error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
	193	name ? name : "null", type);
	194	} else {
	195	*obj = value;
	196	}
	197	}
	198
	199	void visit_type_int8(Visitor v, const char name, int8_t obj, Error *errp)
	200	{
	201	int64_t value = *obj;
	202	visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
	203	*obj = value;
	204	}
	205
	206	void visit_type_int16(Visitor v, const char name, int16_t *obj,
	207	Error **errp)
	208	{
	209	int64_t value = *obj;
	210	visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
	211	*obj = value;
	212	}
	213
	214	void visit_type_int32(Visitor v, const char name, int32_t *obj,
	215	Error **errp)
	216	{
	217	int64_t value = *obj;
	218	visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
	219	*obj = value;
	220	}
	221
	222	void visit_type_int64(Visitor v, const char name, int64_t *obj,
	223	Error **errp)
	224	{
	225	assert(obj);
	226	v->type_int64(v, name, obj, errp);
	227	}
	228
	229	void visit_type_size(Visitor v, const char name, uint64_t *obj,
	230	Error **errp)
	231	{
	232	assert(obj);
	233	if (v->type_size) {
	234	v->type_size(v, name, obj, errp);
	235	} else {
	236	v->type_uint64(v, name, obj, errp);
	237	}
	238	}
	239
	240	void visit_type_bool(Visitor v, const char name, bool obj, Error *errp)
	241	{
	242	assert(obj);
	243	v->type_bool(v, name, obj, errp);
	244	}
	245
	246	void visit_type_str(Visitor v, const char name, char obj, Error errp)
	247	{
	248	Error *err = NULL;
	249
	250	assert(obj);
	251	/* TODO: Fix callers to not pass NULL when they mean "", so that we
	252	* can enable:
	253	assert(v->type != VISITOR_OUTPUT \|\| *obj);
	254	*/
	255	v->type_str(v, name, obj, &err);
	256	if (v->type == VISITOR_INPUT) {
	257	assert(!err != !*obj);
	258	}
	259	error_propagate(errp, err);
	260	}
	261
	262	void visit_type_number(Visitor v, const char name, double *obj,
	263	Error **errp)
	264	{
	265	assert(obj);
	266	v->type_number(v, name, obj, errp);
	267	}
	268
	269	void visit_type_any(Visitor v, const char name, QObject obj, Error errp)
	270	{
	271	Error *err = NULL;
	272
	273	assert(obj);
	274	assert(v->type != VISITOR_OUTPUT \|\| *obj);
	275	v->type_any(v, name, obj, &err);
	276	if (v->type == VISITOR_INPUT) {
	277	assert(!err != !*obj);
	278	}
	279	error_propagate(errp, err);
	280	}
	281
	282	void visit_type_null(Visitor v, const char name, Error **errp)
	283	{
	284	v->type_null(v, name, errp);
	285	}
	286
	287	static void output_type_enum(Visitor v, const char name, int *obj,
	288	const char const strings[], Error *errp)
	289	{
	290	int i = 0;
	291	int value = *obj;
	292	char *enum_str;
	293
	294	while (strings[i++] != NULL);
	295	if (value < 0 \|\| value >= i - 1) {
	296	error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
	297	return;
	298	}
	299
	300	enum_str = (char *)strings[value];
	301	visit_type_str(v, name, &enum_str, errp);
	302	}
	303
	304	static void input_type_enum(Visitor v, const char name, int *obj,
	305	const char const strings[], Error *errp)
	306	{
	307	Error *local_err = NULL;
	308	int64_t value = 0;
	309	char *enum_str;
	310
	311	visit_type_str(v, name, &enum_str, &local_err);
	312	if (local_err) {
	313	error_propagate(errp, local_err);
	314	return;
	315	}
	316
	317	while (strings[value] != NULL) {
	318	if (strcmp(strings[value], enum_str) == 0) {
	319	break;
	320	}
	321	value++;
	322	}
	323
	324	if (strings[value] == NULL) {
	325	error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
	326	g_free(enum_str);
	327	return;
	328	}
	329
	330	g_free(enum_str);
	331	*obj = value;
	332	}
	333
	334	void visit_type_enum(Visitor v, const char name, int *obj,
	335	const char const strings[], Error *errp)
	336	{
	337	assert(obj && strings);
	338	if (v->type == VISITOR_INPUT) {
	339	input_type_enum(v, name, obj, strings, errp);
	340	} else if (v->type == VISITOR_OUTPUT) {
	341	output_type_enum(v, name, obj, strings, errp);
	342	}
	343	}