yizhi-js-lib/favicon-trap
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

we do not need Python to build anymore

Browse Source
This commit is contained in:
Nguyen Anh Quynh
2020-04-30 13:58:33 +08:00
parent 05013b8e47
commit 00bbe2ce7d
14 changed files with 1019 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
qemu/Makefile
View File

@ -34,8 +34,6 @@ endif
endif
GENERATED_HEADERS = config-host.h
GENERATED_HEADERS += qapi-types.h qapi-visit.h
GENERATED_SOURCES += qapi-types.c qapi-visit.c
# Don't try to regenerate Makefile or configure
# We don't generate any of them
@ -91,29 +89,11 @@ recurse-all: $(SUBDIR_RULES)
######################################################################
gen-out-type = $(subst .,-,$(suffix $@))
qapi-py = $(SRC_PATH)/scripts/qapi.py $(SRC_PATH)/scripts/ordereddict.py
qapi-modules = $(SRC_PATH)/qapi-schema.json $(SRC_PATH)/qapi/common.json
qapi-types.c qapi-types.h :\
$(qapi-modules) $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-types.py \
$(gen-out-type) -o "." -b -i $<, \
" GEN $@")
qapi-visit.c qapi-visit.h :\
$(qapi-modules) $(SRC_PATH)/scripts/qapi-visit.py $(qapi-py)
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-visit.py \
$(gen-out-type) -o "." -b -i $<, \
" GEN $@")
clean:
find . \( -name '*.l[oa]' -o -name '*.so' -o -name '*.dll' -o -name '*.mo' -o -name '*.[oda]' \) -type f -exec rm {} +
rm -f TAGS *~ */*~
@# May not be present in GENERATED_HEADERS
rm -f $(foreach f,$(GENERATED_HEADERS),$(f) $(f)-timestamp)
rm -f $(foreach f,$(GENERATED_SOURCES),$(f) $(f)-timestamp)
for d in $(TARGET_DIRS); do \
if test -d $$d; then $(MAKE) -C $$d $@ || exit 1; fi; \
done

24
qemu/configure vendored
View File

@ -451,7 +451,6 @@ Haiku)
esac
: ${make=${MAKE-make}}
: ${python=${PYTHON-python}}
# Default objcc to clang if available, otherwise use CC
if has clang; then
@ -494,8 +493,6 @@ for opt do
;;
--make=*) make="$optarg"
;;
--python=*) python="$optarg"
;;
--extra-cflags=*)
;;
--extra-ldflags=*)
@ -544,24 +541,6 @@ for opt do
esac
done
if ! has $python; then
error_exit "Python not found. Use --python=/path/to/python"
fi
# Note that if the Python conditional here evaluates True we will exit
# with status 1 which is a shell 'false' value.
if ! $python -c 'import sys; sys.exit(sys.version_info < (2,4))'; then
error_exit "Cannot use '$python', Python 2.4 or later is required." \
"Use --python=/path/to/python to specify a supported Python."
fi
# The -B switch was added in Python 2.6.
# If it is supplied, compiled files are not written.
# Use it for Python versions which support it.
if $python -B -c 'import sys; sys.exit(0)' 2>/dev/null; then
python="$python -B"
fi
case "$cpu" in
ppc)
CPU_CFLAGS="-m32"
@ -641,7 +620,6 @@ Advanced options (experts only):
--extra-cflags=CFLAGS append extra C compiler flags QEMU_CFLAGS
--extra-ldflags=LDFLAGS append extra linker flags LDFLAGS
--make=MAKE use specified make [$make]
--python=PYTHON use specified python [$python]
--static enable static build [$static]
--enable-debug-tcg enable TCG debugging
--disable-debug-tcg disable TCG debugging (default)
@ -1083,7 +1061,6 @@ echo "CFLAGS $CFLAGS"
echo "QEMU_CFLAGS $QEMU_CFLAGS"
echo "LDFLAGS $LDFLAGS"
echo "make $make"
echo "python $python"
echo "host CPU $cpu"
echo "host big endian $bigendian"
echo "target list $target_list"
@ -1185,7 +1162,6 @@ fi
QEMU_INCLUDES="-I\$(SRC_PATH)/tcg $QEMU_INCLUDES"
echo "MAKE=$make" >> $config_host_mak
echo "PYTHON=$python" >> $config_host_mak
echo "CC=$cc" >> $config_host_mak
echo "CC_I386=$cc_i386" >> $config_host_mak
echo "HOST_CC=$host_cc" >> $config_host_mak

293
qemu/qapi-types.c Normal file
View File

@ -0,0 +1,293 @@
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
/*
* deallocation functions for schema-defined QAPI types
*
* Copyright IBM, Corp. 2011
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
* Michael Roth <mdroth@linux.vnet.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 "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);
}

228
qemu/qapi-types.h Normal file
View File

@ -0,0 +1,228 @@
/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
/*
* schema-defined QAPI types
*
* 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.
*
*/
#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

428
qemu/qapi-visit.c Normal file
View File

@ -0,0 +1,428 @@
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
/*
* schema-defined QAPI visitor functions
*
* 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-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);
}

51
qemu/qapi-visit.h Normal file
View File

@ -0,0 +1,51 @@
/* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
/*
* schema-defined QAPI visitor functions
*
* 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.
*
*/
#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

0
qemu/qapi-schema.json → qemu/scripts/qapi-schema.json
View File

14
qemu/scripts/qapi.sh Normal file
View File

@ -0,0 +1,14 @@
#!/bin/sh
# Run this scripts to create qapi below files in root dir
# ../qapi-types.c
# ../qapi-types.h
# ../qapi-visit.c
# ../qapi-visit.h
python scripts/qapi-types.py -h -o .. -b -i qapi-schema.json
python scripts/qapi-types.py -c -o .. -b -i qapi-schema.json
python scripts/qapi-visit.py -h -o .. -b -i qapi-schema.json
python scripts/qapi-visit.py -c -o .. -b -i qapi-schema.json

0
qemu/qapi/common.json → qemu/scripts/qapi/common.json
View File