From 00ca6b1a5f4c8bf999385aa08c08fb6d58b5b638 Mon Sep 17 00:00:00 2001 From: xorstream Date: Sat, 21 Jan 2017 00:31:03 +1100 Subject: [PATCH] Save copies of generated qapi files. --- bindings/msvc_native/unicorn/qapi-types.c | 293 +++++++++++++++ bindings/msvc_native/unicorn/qapi-types.h | 228 ++++++++++++ bindings/msvc_native/unicorn/qapi-visit.c | 428 ++++++++++++++++++++++ bindings/msvc_native/unicorn/qapi-visit.h | 51 +++ 4 files changed, 1000 insertions(+) create mode 100644 bindings/msvc_native/unicorn/qapi-types.c create mode 100644 bindings/msvc_native/unicorn/qapi-types.h create mode 100644 bindings/msvc_native/unicorn/qapi-visit.c create mode 100644 bindings/msvc_native/unicorn/qapi-visit.h diff --git a/bindings/msvc_native/unicorn/qapi-types.c b/bindings/msvc_native/unicorn/qapi-types.c new file mode 100644 index 00000000..173c654b --- /dev/null +++ b/bindings/msvc_native/unicorn/qapi-types.c @@ -0,0 +1,293 @@ +/* AUTOMATICALLY GENERATED, DO NOT MODIFY */ + +/* + * deallocation functions for schema-defined QAPI types + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Anthony Liguori + * Michael Roth + * + * 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 "qapi/dealloc-visitor.h" +#include "qapi-types.h" +#include "qapi-visit.h" + +const char *ErrorClass_lookup[] = { + "GenericError", + "CommandNotFound", + "DeviceEncrypted", + "DeviceNotActive", + "DeviceNotFound", + "KVMMissingCap", + NULL, +}; + +const char *X86CPURegister32_lookup[] = { + "EAX", + "EBX", + "ECX", + "EDX", + "ESP", + "EBP", + "ESI", + "EDI", + NULL, +}; + + +#ifndef QAPI_TYPES_BUILTIN_CLEANUP_DEF_H +#define QAPI_TYPES_BUILTIN_CLEANUP_DEF_H + + +void qapi_free_strList(strList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_strList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_intList(intList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_intList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_numberList(numberList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_numberList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_boolList(boolList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_boolList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_int8List(int8List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_int8List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_int16List(int16List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_int16List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_int32List(int32List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_int32List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_int64List(int64List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_int64List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_uint8List(uint8List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_uint8List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_uint16List(uint16List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_uint16List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_uint32List(uint32List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_uint32List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +void qapi_free_uint64List(uint64List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_uint64List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + +#endif /* QAPI_TYPES_BUILTIN_CLEANUP_DEF_H */ + + +void qapi_free_ErrorClassList(ErrorClassList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_ErrorClassList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + + +void qapi_free_X86CPURegister32List(X86CPURegister32List *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_X86CPURegister32List(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + + +void qapi_free_X86CPUFeatureWordInfoList(X86CPUFeatureWordInfoList *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_X86CPUFeatureWordInfoList(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + + +void qapi_free_X86CPUFeatureWordInfo(X86CPUFeatureWordInfo *obj) +{ + QapiDeallocVisitor *md; + Visitor *v; + + if (!obj) { + return; + } + + md = qapi_dealloc_visitor_new(); + v = qapi_dealloc_get_visitor(md); + visit_type_X86CPUFeatureWordInfo(v, &obj, NULL, NULL); + qapi_dealloc_visitor_cleanup(md); +} + diff --git a/bindings/msvc_native/unicorn/qapi-types.h b/bindings/msvc_native/unicorn/qapi-types.h new file mode 100644 index 00000000..944e8825 --- /dev/null +++ b/bindings/msvc_native/unicorn/qapi-types.h @@ -0,0 +1,228 @@ +/* AUTOMATICALLY GENERATED, DO NOT MODIFY */ + +/* + * schema-defined QAPI types + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Anthony Liguori + * + * 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. + * + */ + +#ifndef QAPI_TYPES_H +#define QAPI_TYPES_H + +#include "unicorn/platform.h" + + +#ifndef QAPI_TYPES_BUILTIN_STRUCT_DECL_H +#define QAPI_TYPES_BUILTIN_STRUCT_DECL_H + + +typedef struct strList +{ + union { + char *value; + uint64_t padding; + }; + struct strList *next; +} strList; + +typedef struct intList +{ + union { + int64_t value; + uint64_t padding; + }; + struct intList *next; +} intList; + +typedef struct numberList +{ + union { + double value; + uint64_t padding; + }; + struct numberList *next; +} numberList; + +typedef struct boolList +{ + union { + bool value; + uint64_t padding; + }; + struct boolList *next; +} boolList; + +typedef struct int8List +{ + union { + int8_t value; + uint64_t padding; + }; + struct int8List *next; +} int8List; + +typedef struct int16List +{ + union { + int16_t value; + uint64_t padding; + }; + struct int16List *next; +} int16List; + +typedef struct int32List +{ + union { + int32_t value; + uint64_t padding; + }; + struct int32List *next; +} int32List; + +typedef struct int64List +{ + union { + int64_t value; + uint64_t padding; + }; + struct int64List *next; +} int64List; + +typedef struct uint8List +{ + union { + uint8_t value; + uint64_t padding; + }; + struct uint8List *next; +} uint8List; + +typedef struct uint16List +{ + union { + uint16_t value; + uint64_t padding; + }; + struct uint16List *next; +} uint16List; + +typedef struct uint32List +{ + union { + uint32_t value; + uint64_t padding; + }; + struct uint32List *next; +} uint32List; + +typedef struct uint64List +{ + union { + uint64_t value; + uint64_t padding; + }; + struct uint64List *next; +} uint64List; + +#endif /* QAPI_TYPES_BUILTIN_STRUCT_DECL_H */ + + +extern const char *ErrorClass_lookup[]; +typedef enum ErrorClass +{ + ERROR_CLASS_GENERIC_ERROR = 0, + ERROR_CLASS_COMMAND_NOT_FOUND = 1, + ERROR_CLASS_DEVICE_ENCRYPTED = 2, + ERROR_CLASS_DEVICE_NOT_ACTIVE = 3, + ERROR_CLASS_DEVICE_NOT_FOUND = 4, + ERROR_CLASS_KVM_MISSING_CAP = 5, + ERROR_CLASS_MAX = 6, +} ErrorClass; + +typedef struct ErrorClassList +{ + union { + ErrorClass value; + uint64_t padding; + }; + struct ErrorClassList *next; +} ErrorClassList; + +extern const char *X86CPURegister32_lookup[]; +typedef enum X86CPURegister32 +{ + X86_CPU_REGISTER32_EAX = 0, + X86_CPU_REGISTER32_EBX = 1, + X86_CPU_REGISTER32_ECX = 2, + X86_CPU_REGISTER32_EDX = 3, + X86_CPU_REGISTER32_ESP = 4, + X86_CPU_REGISTER32_EBP = 5, + X86_CPU_REGISTER32_ESI = 6, + X86_CPU_REGISTER32_EDI = 7, + X86_CPU_REGISTER32_MAX = 8, +} X86CPURegister32; + +typedef struct X86CPURegister32List +{ + union { + X86CPURegister32 value; + uint64_t padding; + }; + struct X86CPURegister32List *next; +} X86CPURegister32List; + + +typedef struct X86CPUFeatureWordInfo X86CPUFeatureWordInfo; + +typedef struct X86CPUFeatureWordInfoList +{ + union { + X86CPUFeatureWordInfo *value; + uint64_t padding; + }; + struct X86CPUFeatureWordInfoList *next; +} X86CPUFeatureWordInfoList; + +#ifndef QAPI_TYPES_BUILTIN_CLEANUP_DECL_H +#define QAPI_TYPES_BUILTIN_CLEANUP_DECL_H + +void qapi_free_strList(strList *obj); +void qapi_free_intList(intList *obj); +void qapi_free_numberList(numberList *obj); +void qapi_free_boolList(boolList *obj); +void qapi_free_int8List(int8List *obj); +void qapi_free_int16List(int16List *obj); +void qapi_free_int32List(int32List *obj); +void qapi_free_int64List(int64List *obj); +void qapi_free_uint8List(uint8List *obj); +void qapi_free_uint16List(uint16List *obj); +void qapi_free_uint32List(uint32List *obj); +void qapi_free_uint64List(uint64List *obj); + +#endif /* QAPI_TYPES_BUILTIN_CLEANUP_DECL_H */ + + +void qapi_free_ErrorClassList(ErrorClassList *obj); + +void qapi_free_X86CPURegister32List(X86CPURegister32List *obj); + +struct X86CPUFeatureWordInfo +{ + int64_t cpuid_input_eax; + bool has_cpuid_input_ecx; + int64_t cpuid_input_ecx; + X86CPURegister32 cpuid_register; + int64_t features; +}; + +void qapi_free_X86CPUFeatureWordInfoList(X86CPUFeatureWordInfoList *obj); +void qapi_free_X86CPUFeatureWordInfo(X86CPUFeatureWordInfo *obj); + +#endif diff --git a/bindings/msvc_native/unicorn/qapi-visit.c b/bindings/msvc_native/unicorn/qapi-visit.c new file mode 100644 index 00000000..7733bb55 --- /dev/null +++ b/bindings/msvc_native/unicorn/qapi-visit.c @@ -0,0 +1,428 @@ +/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */ + +/* + * schema-defined QAPI visitor functions + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Anthony Liguori + * + * 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-common.h" +#include "qapi-visit.h" + +void visit_type_strList(Visitor *m, strList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + strList *native_i = (strList *)i; + visit_type_str(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_intList(Visitor *m, intList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + intList *native_i = (intList *)i; + visit_type_int(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_numberList(Visitor *m, numberList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + numberList *native_i = (numberList *)i; + visit_type_number(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_boolList(Visitor *m, boolList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + boolList *native_i = (boolList *)i; + visit_type_bool(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_int8List(Visitor *m, int8List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + int8List *native_i = (int8List *)i; + visit_type_int8(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_int16List(Visitor *m, int16List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + int16List *native_i = (int16List *)i; + visit_type_int16(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_int32List(Visitor *m, int32List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + int32List *native_i = (int32List *)i; + visit_type_int32(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_int64List(Visitor *m, int64List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + int64List *native_i = (int64List *)i; + visit_type_int64(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_uint8List(Visitor *m, uint8List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + uint8List *native_i = (uint8List *)i; + visit_type_uint8(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_uint16List(Visitor *m, uint16List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + uint16List *native_i = (uint16List *)i; + visit_type_uint16(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_uint32List(Visitor *m, uint32List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + uint32List *native_i = (uint32List *)i; + visit_type_uint32(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_uint64List(Visitor *m, uint64List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + uint64List *native_i = (uint64List *)i; + visit_type_uint64(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_ErrorClassList(Visitor *m, ErrorClassList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + ErrorClassList *native_i = (ErrorClassList *)i; + visit_type_ErrorClass(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_ErrorClass(Visitor *m, ErrorClass *obj, const char *name, Error **errp) +{ + visit_type_enum(m, (int *)obj, ErrorClass_lookup, "ErrorClass", name, errp); +} + +void visit_type_X86CPURegister32List(Visitor *m, X86CPURegister32List **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + X86CPURegister32List *native_i = (X86CPURegister32List *)i; + visit_type_X86CPURegister32(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} + +void visit_type_X86CPURegister32(Visitor *m, X86CPURegister32 *obj, const char *name, Error **errp) +{ + visit_type_enum(m, (int *)obj, X86CPURegister32_lookup, "X86CPURegister32", name, errp); +} + +static void visit_type_X86CPUFeatureWordInfo_fields(Visitor *m, X86CPUFeatureWordInfo **obj, Error **errp) +{ + Error *err = NULL; + visit_type_int(m, &(*obj)->cpuid_input_eax, "cpuid-input-eax", &err); + if (err) { + goto out; + } + visit_optional(m, &(*obj)->has_cpuid_input_ecx, "cpuid-input-ecx", &err); + if (!err && (*obj)->has_cpuid_input_ecx) { + visit_type_int(m, &(*obj)->cpuid_input_ecx, "cpuid-input-ecx", &err); + } + if (err) { + goto out; + } + visit_type_X86CPURegister32(m, &(*obj)->cpuid_register, "cpuid-register", &err); + if (err) { + goto out; + } + visit_type_int(m, &(*obj)->features, "features", &err); + if (err) { + goto out; + } + +out: + error_propagate(errp, err); +} + +void visit_type_X86CPUFeatureWordInfo(Visitor *m, X86CPUFeatureWordInfo **obj, const char *name, Error **errp) +{ + Error *err = NULL; + + visit_start_struct(m, (void **)obj, "X86CPUFeatureWordInfo", name, sizeof(X86CPUFeatureWordInfo), &err); + if (!err) { + if (*obj) { + visit_type_X86CPUFeatureWordInfo_fields(m, obj, errp); + } + visit_end_struct(m, &err); + } + error_propagate(errp, err); +} + +void visit_type_X86CPUFeatureWordInfoList(Visitor *m, X86CPUFeatureWordInfoList **obj, const char *name, Error **errp) +{ + Error *err = NULL; + GenericList *i, **prev; + + visit_start_list(m, name, &err); + if (err) { + goto out; + } + + for (prev = (GenericList **)obj; + !err && (i = visit_next_list(m, prev, &err)) != NULL; + prev = &i) { + X86CPUFeatureWordInfoList *native_i = (X86CPUFeatureWordInfoList *)i; + visit_type_X86CPUFeatureWordInfo(m, &native_i->value, NULL, &err); + } + + error_propagate(errp, err); + err = NULL; + visit_end_list(m, &err); +out: + error_propagate(errp, err); +} diff --git a/bindings/msvc_native/unicorn/qapi-visit.h b/bindings/msvc_native/unicorn/qapi-visit.h new file mode 100644 index 00000000..51bd0887 --- /dev/null +++ b/bindings/msvc_native/unicorn/qapi-visit.h @@ -0,0 +1,51 @@ +/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */ + +/* + * schema-defined QAPI visitor functions + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Anthony Liguori + * + * 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. + * + */ + +#ifndef QAPI_VISIT_H +#define QAPI_VISIT_H + +#include "qapi/visitor.h" +#include "qapi-types.h" + + +#ifndef QAPI_VISIT_BUILTIN_VISITOR_DECL_H +#define QAPI_VISIT_BUILTIN_VISITOR_DECL_H + +void visit_type_strList(Visitor *m, strList **obj, const char *name, Error **errp); +void visit_type_intList(Visitor *m, intList **obj, const char *name, Error **errp); +void visit_type_numberList(Visitor *m, numberList **obj, const char *name, Error **errp); +void visit_type_boolList(Visitor *m, boolList **obj, const char *name, Error **errp); +void visit_type_int8List(Visitor *m, int8List **obj, const char *name, Error **errp); +void visit_type_int16List(Visitor *m, int16List **obj, const char *name, Error **errp); +void visit_type_int32List(Visitor *m, int32List **obj, const char *name, Error **errp); +void visit_type_int64List(Visitor *m, int64List **obj, const char *name, Error **errp); +void visit_type_uint8List(Visitor *m, uint8List **obj, const char *name, Error **errp); +void visit_type_uint16List(Visitor *m, uint16List **obj, const char *name, Error **errp); +void visit_type_uint32List(Visitor *m, uint32List **obj, const char *name, Error **errp); +void visit_type_uint64List(Visitor *m, uint64List **obj, const char *name, Error **errp); + +#endif /* QAPI_VISIT_BUILTIN_VISITOR_DECL_H */ + + +void visit_type_ErrorClass(Visitor *m, ErrorClass *obj, const char *name, Error **errp); +void visit_type_ErrorClassList(Visitor *m, ErrorClassList **obj, const char *name, Error **errp); + +void visit_type_X86CPURegister32(Visitor *m, X86CPURegister32 *obj, const char *name, Error **errp); +void visit_type_X86CPURegister32List(Visitor *m, X86CPURegister32List **obj, const char *name, Error **errp); + +void visit_type_X86CPUFeatureWordInfo(Visitor *m, X86CPUFeatureWordInfo **obj, const char *name, Error **errp); +void visit_type_X86CPUFeatureWordInfoList(Visitor *m, X86CPUFeatureWordInfoList **obj, const char *name, Error **errp); + +#endif