Browse Source
We would like to use a same QObject type to represent numbers, whether they are int, uint, or floats. Getters will allow some compatibility between the various types if the number fits other representations. Add a few more tests while at it. Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> Message-Id: <20170607163635.17635-7-marcandre.lureau@redhat.com> Reviewed-by: Markus Armbruster <armbru@redhat.com> [parse_stats_intervals() simplified a bit, comment in test_visitor_in_int_overflow() tidied up, suppress bogus warnings] Signed-off-by: Markus Armbruster <armbru@redhat.com>pull/53/head
Marc-André Lureau
9 years ago
committed by
Markus Armbruster
Markus Armbruster
65 changed files with 630 additions and 664 deletions
@ -1,29 +0,0 @@ |
|||
/*
|
|||
* QFloat Module |
|||
* |
|||
* Copyright IBM, Corp. 2009 |
|||
* |
|||
* 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 QFLOAT_H |
|||
#define QFLOAT_H |
|||
|
|||
#include "qapi/qmp/qobject.h" |
|||
|
|||
typedef struct QFloat { |
|||
QObject base; |
|||
double value; |
|||
} QFloat; |
|||
|
|||
QFloat *qfloat_from_double(double value); |
|||
double qfloat_get_double(const QFloat *qi); |
|||
QFloat *qobject_to_qfloat(const QObject *obj); |
|||
void qfloat_destroy_obj(QObject *obj); |
|||
|
|||
#endif /* QFLOAT_H */ |
|||
@ -1,28 +0,0 @@ |
|||
/*
|
|||
* QInt Module |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@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. |
|||
*/ |
|||
|
|||
#ifndef QINT_H |
|||
#define QINT_H |
|||
|
|||
#include "qapi/qmp/qobject.h" |
|||
|
|||
typedef struct QInt { |
|||
QObject base; |
|||
int64_t value; |
|||
} QInt; |
|||
|
|||
QInt *qint_from_int(int64_t value); |
|||
int64_t qint_get_int(const QInt *qi); |
|||
QInt *qobject_to_qint(const QObject *obj); |
|||
void qint_destroy_obj(QObject *obj); |
|||
|
|||
#endif /* QINT_H */ |
|||
@ -0,0 +1,46 @@ |
|||
/*
|
|||
* QNum Module |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@redhat.com> |
|||
* Anthony Liguori <aliguori@us.ibm.com> |
|||
* Marc-André Lureau <marcandre.lureau@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. |
|||
*/ |
|||
|
|||
#ifndef QNUM_H |
|||
#define QNUM_H |
|||
|
|||
#include "qapi/qmp/qobject.h" |
|||
|
|||
typedef enum { |
|||
QNUM_I64, |
|||
QNUM_DOUBLE |
|||
} QNumKind; |
|||
|
|||
typedef struct QNum { |
|||
QObject base; |
|||
QNumKind kind; |
|||
union { |
|||
int64_t i64; |
|||
double dbl; |
|||
} u; |
|||
} QNum; |
|||
|
|||
QNum *qnum_from_int(int64_t value); |
|||
QNum *qnum_from_double(double value); |
|||
|
|||
bool qnum_get_try_int(const QNum *qn, int64_t *val); |
|||
int64_t qnum_get_int(const QNum *qn); |
|||
double qnum_get_double(QNum *qn); |
|||
|
|||
char *qnum_to_string(QNum *qn); |
|||
|
|||
QNum *qobject_to_qnum(const QObject *obj); |
|||
void qnum_destroy_obj(QObject *obj); |
|||
|
|||
#endif /* QNUM_H */ |
|||
@ -1,2 +1,2 @@ |
|||
util-obj-y = qnull.o qint.o qstring.o qdict.o qlist.o qfloat.o qbool.o |
|||
util-obj-y = qnull.o qnum.o qstring.o qdict.o qlist.o qbool.o |
|||
util-obj-y += qjson.o qobject.o json-lexer.o json-streamer.o json-parser.o |
|||
|
|||
@ -1,62 +0,0 @@ |
|||
/*
|
|||
* QFloat Module |
|||
* |
|||
* Copyright IBM, Corp. 2009 |
|||
* |
|||
* 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/qmp/qfloat.h" |
|||
#include "qapi/qmp/qobject.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/**
|
|||
* qfloat_from_int(): Create a new QFloat from a float |
|||
* |
|||
* Return strong reference. |
|||
*/ |
|||
QFloat *qfloat_from_double(double value) |
|||
{ |
|||
QFloat *qf; |
|||
|
|||
qf = g_malloc(sizeof(*qf)); |
|||
qobject_init(QOBJECT(qf), QTYPE_QFLOAT); |
|||
qf->value = value; |
|||
|
|||
return qf; |
|||
} |
|||
|
|||
/**
|
|||
* qfloat_get_double(): Get the stored float |
|||
*/ |
|||
double qfloat_get_double(const QFloat *qf) |
|||
{ |
|||
return qf->value; |
|||
} |
|||
|
|||
/**
|
|||
* qobject_to_qfloat(): Convert a QObject into a QFloat |
|||
*/ |
|||
QFloat *qobject_to_qfloat(const QObject *obj) |
|||
{ |
|||
if (!obj || qobject_type(obj) != QTYPE_QFLOAT) { |
|||
return NULL; |
|||
} |
|||
return container_of(obj, QFloat, base); |
|||
} |
|||
|
|||
/**
|
|||
* qfloat_destroy_obj(): Free all memory allocated by a |
|||
* QFloat object |
|||
*/ |
|||
void qfloat_destroy_obj(QObject *obj) |
|||
{ |
|||
assert(obj != NULL); |
|||
g_free(qobject_to_qfloat(obj)); |
|||
} |
|||
@ -1,61 +0,0 @@ |
|||
/*
|
|||
* QInt Module |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@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 "qapi/qmp/qint.h" |
|||
#include "qapi/qmp/qobject.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/**
|
|||
* qint_from_int(): Create a new QInt from an int64_t |
|||
* |
|||
* Return strong reference. |
|||
*/ |
|||
QInt *qint_from_int(int64_t value) |
|||
{ |
|||
QInt *qi; |
|||
|
|||
qi = g_malloc(sizeof(*qi)); |
|||
qobject_init(QOBJECT(qi), QTYPE_QINT); |
|||
qi->value = value; |
|||
|
|||
return qi; |
|||
} |
|||
|
|||
/**
|
|||
* qint_get_int(): Get the stored integer |
|||
*/ |
|||
int64_t qint_get_int(const QInt *qi) |
|||
{ |
|||
return qi->value; |
|||
} |
|||
|
|||
/**
|
|||
* qobject_to_qint(): Convert a QObject into a QInt |
|||
*/ |
|||
QInt *qobject_to_qint(const QObject *obj) |
|||
{ |
|||
if (!obj || qobject_type(obj) != QTYPE_QINT) { |
|||
return NULL; |
|||
} |
|||
return container_of(obj, QInt, base); |
|||
} |
|||
|
|||
/**
|
|||
* qint_destroy_obj(): Free all memory allocated by a |
|||
* QInt object |
|||
*/ |
|||
void qint_destroy_obj(QObject *obj) |
|||
{ |
|||
assert(obj != NULL); |
|||
g_free(qobject_to_qint(obj)); |
|||
} |
|||
@ -0,0 +1,159 @@ |
|||
/*
|
|||
* QNum Module |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@redhat.com> |
|||
* Anthony Liguori <aliguori@us.ibm.com> |
|||
* Marc-André Lureau <marcandre.lureau@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 "qapi/error.h" |
|||
#include "qapi/qmp/qnum.h" |
|||
#include "qapi/qmp/qobject.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/**
|
|||
* qnum_from_int(): Create a new QNum from an int64_t |
|||
* |
|||
* Return strong reference. |
|||
*/ |
|||
QNum *qnum_from_int(int64_t value) |
|||
{ |
|||
QNum *qn = g_new(QNum, 1); |
|||
|
|||
qobject_init(QOBJECT(qn), QTYPE_QNUM); |
|||
qn->kind = QNUM_I64; |
|||
qn->u.i64 = value; |
|||
|
|||
return qn; |
|||
} |
|||
|
|||
/**
|
|||
* qnum_from_double(): Create a new QNum from a double |
|||
* |
|||
* Return strong reference. |
|||
*/ |
|||
QNum *qnum_from_double(double value) |
|||
{ |
|||
QNum *qn = g_new(QNum, 1); |
|||
|
|||
qobject_init(QOBJECT(qn), QTYPE_QNUM); |
|||
qn->kind = QNUM_DOUBLE; |
|||
qn->u.dbl = value; |
|||
|
|||
return qn; |
|||
} |
|||
|
|||
/**
|
|||
* qnum_get_try_int(): Get an integer representation of the number |
|||
* |
|||
* Return true on success. |
|||
*/ |
|||
bool qnum_get_try_int(const QNum *qn, int64_t *val) |
|||
{ |
|||
switch (qn->kind) { |
|||
case QNUM_I64: |
|||
*val = qn->u.i64; |
|||
return true; |
|||
case QNUM_DOUBLE: |
|||
return false; |
|||
} |
|||
|
|||
assert(0); |
|||
return false; |
|||
} |
|||
|
|||
/**
|
|||
* qnum_get_int(): Get an integer representation of the number |
|||
* |
|||
* assert() on failure. |
|||
*/ |
|||
int64_t qnum_get_int(const QNum *qn) |
|||
{ |
|||
int64_t val; |
|||
bool success = qnum_get_try_int(qn, &val); |
|||
assert(success); |
|||
return val; |
|||
} |
|||
|
|||
/**
|
|||
* qnum_get_double(): Get a float representation of the number |
|||
* |
|||
* qnum_get_double() loses precision for integers beyond 53 bits. |
|||
*/ |
|||
double qnum_get_double(QNum *qn) |
|||
{ |
|||
switch (qn->kind) { |
|||
case QNUM_I64: |
|||
return qn->u.i64; |
|||
case QNUM_DOUBLE: |
|||
return qn->u.dbl; |
|||
} |
|||
|
|||
assert(0); |
|||
return 0.0; |
|||
} |
|||
|
|||
char *qnum_to_string(QNum *qn) |
|||
{ |
|||
char *buffer; |
|||
int len; |
|||
|
|||
switch (qn->kind) { |
|||
case QNUM_I64: |
|||
return g_strdup_printf("%" PRId64, qn->u.i64); |
|||
case QNUM_DOUBLE: |
|||
/* FIXME: snprintf() is locale dependent; but JSON requires
|
|||
* numbers to be formatted as if in the C locale. Dependence |
|||
* on C locale is a pervasive issue in QEMU. */ |
|||
/* FIXME: This risks printing Inf or NaN, which are not valid
|
|||
* JSON values. */ |
|||
/* FIXME: the default precision of 6 for %f often causes
|
|||
* rounding errors; we should be using DBL_DECIMAL_DIG (17), |
|||
* and only rounding to a shorter number if the result would |
|||
* still produce the same floating point value. */ |
|||
buffer = g_strdup_printf("%f" , qn->u.dbl); |
|||
len = strlen(buffer); |
|||
while (len > 0 && buffer[len - 1] == '0') { |
|||
len--; |
|||
} |
|||
|
|||
if (len && buffer[len - 1] == '.') { |
|||
buffer[len - 1] = 0; |
|||
} else { |
|||
buffer[len] = 0; |
|||
} |
|||
|
|||
return buffer; |
|||
} |
|||
|
|||
assert(0); |
|||
return NULL; |
|||
} |
|||
|
|||
/**
|
|||
* qobject_to_qnum(): Convert a QObject into a QNum |
|||
*/ |
|||
QNum *qobject_to_qnum(const QObject *obj) |
|||
{ |
|||
if (!obj || qobject_type(obj) != QTYPE_QNUM) { |
|||
return NULL; |
|||
} |
|||
return container_of(obj, QNum, base); |
|||
} |
|||
|
|||
/**
|
|||
* qnum_destroy_obj(): Free all memory allocated by a |
|||
* QNum object |
|||
*/ |
|||
void qnum_destroy_obj(QObject *obj) |
|||
{ |
|||
assert(obj != NULL); |
|||
g_free(qobject_to_qnum(obj)); |
|||
} |
|||
@ -1,53 +0,0 @@ |
|||
/*
|
|||
* QFloat unit-tests. |
|||
* |
|||
* Copyright IBM, Corp. 2009 |
|||
* |
|||
* 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/qmp/qfloat.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/*
|
|||
* Public Interface test-cases |
|||
* |
|||
* (with some violations to access 'private' data) |
|||
*/ |
|||
|
|||
static void qfloat_from_double_test(void) |
|||
{ |
|||
QFloat *qf; |
|||
const double value = -42.23423; |
|||
|
|||
qf = qfloat_from_double(value); |
|||
g_assert(qf != NULL); |
|||
g_assert(qf->value == value); |
|||
g_assert(qf->base.refcnt == 1); |
|||
g_assert(qobject_type(QOBJECT(qf)) == QTYPE_QFLOAT); |
|||
|
|||
// destroy doesn't exit yet
|
|||
g_free(qf); |
|||
} |
|||
|
|||
static void qfloat_destroy_test(void) |
|||
{ |
|||
QFloat *qf = qfloat_from_double(0.0); |
|||
QDECREF(qf); |
|||
} |
|||
|
|||
int main(int argc, char **argv) |
|||
{ |
|||
g_test_init(&argc, &argv, NULL); |
|||
|
|||
g_test_add_func("/public/from_double", qfloat_from_double_test); |
|||
g_test_add_func("/public/destroy", qfloat_destroy_test); |
|||
|
|||
return g_test_run(); |
|||
} |
|||
@ -1,87 +0,0 @@ |
|||
/*
|
|||
* QInt unit-tests. |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@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 "qapi/qmp/qint.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/*
|
|||
* Public Interface test-cases |
|||
* |
|||
* (with some violations to access 'private' data) |
|||
*/ |
|||
|
|||
static void qint_from_int_test(void) |
|||
{ |
|||
QInt *qi; |
|||
const int value = -42; |
|||
|
|||
qi = qint_from_int(value); |
|||
g_assert(qi != NULL); |
|||
g_assert(qi->value == value); |
|||
g_assert(qi->base.refcnt == 1); |
|||
g_assert(qobject_type(QOBJECT(qi)) == QTYPE_QINT); |
|||
|
|||
// destroy doesn't exit yet
|
|||
g_free(qi); |
|||
} |
|||
|
|||
static void qint_destroy_test(void) |
|||
{ |
|||
QInt *qi = qint_from_int(0); |
|||
QDECREF(qi); |
|||
} |
|||
|
|||
static void qint_from_int64_test(void) |
|||
{ |
|||
QInt *qi; |
|||
const int64_t value = 0x1234567890abcdefLL; |
|||
|
|||
qi = qint_from_int(value); |
|||
g_assert((int64_t) qi->value == value); |
|||
|
|||
QDECREF(qi); |
|||
} |
|||
|
|||
static void qint_get_int_test(void) |
|||
{ |
|||
QInt *qi; |
|||
const int value = 123456; |
|||
|
|||
qi = qint_from_int(value); |
|||
g_assert(qint_get_int(qi) == value); |
|||
|
|||
QDECREF(qi); |
|||
} |
|||
|
|||
static void qobject_to_qint_test(void) |
|||
{ |
|||
QInt *qi; |
|||
|
|||
qi = qint_from_int(0); |
|||
g_assert(qobject_to_qint(QOBJECT(qi)) == qi); |
|||
|
|||
QDECREF(qi); |
|||
} |
|||
|
|||
int main(int argc, char **argv) |
|||
{ |
|||
g_test_init(&argc, &argv, NULL); |
|||
|
|||
g_test_add_func("/public/from_int", qint_from_int_test); |
|||
g_test_add_func("/public/destroy", qint_destroy_test); |
|||
g_test_add_func("/public/from_int64", qint_from_int64_test); |
|||
g_test_add_func("/public/get_int", qint_get_int_test); |
|||
g_test_add_func("/public/to_qint", qobject_to_qint_test); |
|||
|
|||
return g_test_run(); |
|||
} |
|||
@ -0,0 +1,136 @@ |
|||
/*
|
|||
* QNum unit-tests. |
|||
* |
|||
* Copyright (C) 2009 Red Hat Inc. |
|||
* Copyright IBM, Corp. 2009 |
|||
* |
|||
* Authors: |
|||
* Luiz Capitulino <lcapitulino@redhat.com> |
|||
* 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/qmp/qnum.h" |
|||
#include "qapi/error.h" |
|||
#include "qemu-common.h" |
|||
|
|||
/*
|
|||
* Public Interface test-cases |
|||
* |
|||
* (with some violations to access 'private' data) |
|||
*/ |
|||
|
|||
static void qnum_from_int_test(void) |
|||
{ |
|||
QNum *qn; |
|||
const int value = -42; |
|||
|
|||
qn = qnum_from_int(value); |
|||
g_assert(qn != NULL); |
|||
g_assert_cmpint(qn->kind, ==, QNUM_I64); |
|||
g_assert_cmpint(qn->u.i64, ==, value); |
|||
g_assert_cmpint(qn->base.refcnt, ==, 1); |
|||
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM); |
|||
|
|||
// destroy doesn't exit yet
|
|||
g_free(qn); |
|||
} |
|||
|
|||
static void qnum_from_double_test(void) |
|||
{ |
|||
QNum *qn; |
|||
const double value = -42.23423; |
|||
|
|||
qn = qnum_from_double(value); |
|||
g_assert(qn != NULL); |
|||
g_assert_cmpint(qn->kind, ==, QNUM_DOUBLE); |
|||
g_assert_cmpfloat(qn->u.dbl, ==, value); |
|||
g_assert_cmpint(qn->base.refcnt, ==, 1); |
|||
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM); |
|||
|
|||
// destroy doesn't exit yet
|
|||
g_free(qn); |
|||
} |
|||
|
|||
static void qnum_from_int64_test(void) |
|||
{ |
|||
QNum *qn; |
|||
const int64_t value = 0x1234567890abcdefLL; |
|||
|
|||
qn = qnum_from_int(value); |
|||
g_assert_cmpint((int64_t) qn->u.i64, ==, value); |
|||
|
|||
QDECREF(qn); |
|||
} |
|||
|
|||
static void qnum_get_int_test(void) |
|||
{ |
|||
QNum *qn; |
|||
const int value = 123456; |
|||
|
|||
qn = qnum_from_int(value); |
|||
g_assert_cmpint(qnum_get_int(qn), ==, value); |
|||
|
|||
QDECREF(qn); |
|||
} |
|||
|
|||
static void qobject_to_qnum_test(void) |
|||
{ |
|||
QNum *qn; |
|||
|
|||
qn = qnum_from_int(0); |
|||
g_assert(qobject_to_qnum(QOBJECT(qn)) == qn); |
|||
QDECREF(qn); |
|||
|
|||
qn = qnum_from_double(0); |
|||
g_assert(qobject_to_qnum(QOBJECT(qn)) == qn); |
|||
QDECREF(qn); |
|||
} |
|||
|
|||
static void qnum_to_string_test(void) |
|||
{ |
|||
QNum *qn; |
|||
char *tmp; |
|||
|
|||
qn = qnum_from_int(123456); |
|||
tmp = qnum_to_string(qn); |
|||
g_assert_cmpstr(tmp, ==, "123456"); |
|||
g_free(tmp); |
|||
QDECREF(qn); |
|||
|
|||
qn = qnum_from_double(0.42); |
|||
tmp = qnum_to_string(qn); |
|||
g_assert_cmpstr(tmp, ==, "0.42"); |
|||
g_free(tmp); |
|||
QDECREF(qn); |
|||
} |
|||
|
|||
static void qnum_destroy_test(void) |
|||
{ |
|||
QNum *qn; |
|||
|
|||
qn = qnum_from_int(0); |
|||
QDECREF(qn); |
|||
|
|||
qn = qnum_from_double(0.42); |
|||
QDECREF(qn); |
|||
} |
|||
|
|||
int main(int argc, char **argv) |
|||
{ |
|||
g_test_init(&argc, &argv, NULL); |
|||
|
|||
g_test_add_func("/qnum/from_int", qnum_from_int_test); |
|||
g_test_add_func("/qnum/from_double", qnum_from_double_test); |
|||
g_test_add_func("/qnum/destroy", qnum_destroy_test); |
|||
g_test_add_func("/qnum/from_int64", qnum_from_int64_test); |
|||
g_test_add_func("/qnum/get_int", qnum_get_int_test); |
|||
g_test_add_func("/qnum/to_qnum", qobject_to_qnum_test); |
|||
g_test_add_func("/qnum/to_string", qnum_to_string_test); |
|||
|
|||
return g_test_run(); |
|||
} |
|||
@ -1,4 +1,4 @@ |
|||
enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbool'] |
|||
enum QType ['none', 'qnull', 'qnum', 'qstring', 'qdict', 'qlist', 'qbool'] |
|||
prefix QTYPE |
|||
enum Status ['good', 'bad', 'ugly'] |
|||
object q_empty |
|||
|
|||
@ -1,3 +1,3 @@ |
|||
enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbool'] |
|||
enum QType ['none', 'qnull', 'qnum', 'qstring', 'qdict', 'qlist', 'qbool'] |
|||
prefix QTYPE |
|||
object q_empty |
|||
|
|||
@ -1,4 +1,4 @@ |
|||
enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbool'] |
|||
enum QType ['none', 'qnull', 'qnum', 'qstring', 'qdict', 'qlist', 'qbool'] |
|||
prefix QTYPE |
|||
enum Status ['good', 'bad', 'ugly'] |
|||
object q_empty |
|||
|
|||
@ -1,4 +1,4 @@ |
|||
enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbool'] |
|||
enum QType ['none', 'qnull', 'qnum', 'qstring', 'qdict', 'qlist', 'qbool'] |
|||
prefix QTYPE |
|||
enum Status ['good', 'bad', 'ugly'] |
|||
object q_empty |
|||
|
|||
@ -1,4 +1,4 @@ |
|||
enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbool'] |
|||
enum QType ['none', 'qnull', 'qnum', 'qstring', 'qdict', 'qlist', 'qbool'] |
|||
prefix QTYPE |
|||
enum Status ['good', 'bad', 'ugly'] |
|||
object q_empty |
|||
|
|||
Loading…
Reference in new issue