Merge remote-tracking branch 'remotes/vivier2/tags/trivial-branch-for-5.2-pull-reques...
[qemu.git] / qobject / qnum.c
1 /*
2 * QNum Module
3 *
4 * Copyright (C) 2009 Red Hat Inc.
5 *
6 * Authors:
7 * Luiz Capitulino <lcapitulino@redhat.com>
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Marc-André Lureau <marcandre.lureau@redhat.com>
10 *
11 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
12 * See the COPYING.LIB file in the top-level directory.
13 */
14
15 #include "qemu/osdep.h"
16 #include "qapi/qmp/qnum.h"
17
18 /**
19 * qnum_from_int(): Create a new QNum from an int64_t
20 *
21 * Return strong reference.
22 */
23 QNum *qnum_from_int(int64_t value)
24 {
25 QNum *qn = g_new(QNum, 1);
26
27 qobject_init(QOBJECT(qn), QTYPE_QNUM);
28 qn->kind = QNUM_I64;
29 qn->u.i64 = value;
30
31 return qn;
32 }
33
34 /**
35 * qnum_from_uint(): Create a new QNum from an uint64_t
36 *
37 * Return strong reference.
38 */
39 QNum *qnum_from_uint(uint64_t value)
40 {
41 QNum *qn = g_new(QNum, 1);
42
43 qobject_init(QOBJECT(qn), QTYPE_QNUM);
44 qn->kind = QNUM_U64;
45 qn->u.u64 = value;
46
47 return qn;
48 }
49
50 /**
51 * qnum_from_double(): Create a new QNum from a double
52 *
53 * Return strong reference.
54 */
55 QNum *qnum_from_double(double value)
56 {
57 QNum *qn = g_new(QNum, 1);
58
59 qobject_init(QOBJECT(qn), QTYPE_QNUM);
60 qn->kind = QNUM_DOUBLE;
61 qn->u.dbl = value;
62
63 return qn;
64 }
65
66 /**
67 * qnum_get_try_int(): Get an integer representation of the number
68 *
69 * Return true on success.
70 */
71 bool qnum_get_try_int(const QNum *qn, int64_t *val)
72 {
73 switch (qn->kind) {
74 case QNUM_I64:
75 *val = qn->u.i64;
76 return true;
77 case QNUM_U64:
78 if (qn->u.u64 > INT64_MAX) {
79 return false;
80 }
81 *val = qn->u.u64;
82 return true;
83 case QNUM_DOUBLE:
84 return false;
85 }
86
87 assert(0);
88 return false;
89 }
90
91 /**
92 * qnum_get_int(): Get an integer representation of the number
93 *
94 * assert() on failure.
95 */
96 int64_t qnum_get_int(const QNum *qn)
97 {
98 int64_t val;
99 bool success = qnum_get_try_int(qn, &val);
100 assert(success);
101 return val;
102 }
103
104 /**
105 * qnum_get_uint(): Get an unsigned integer from the number
106 *
107 * Return true on success.
108 */
109 bool qnum_get_try_uint(const QNum *qn, uint64_t *val)
110 {
111 switch (qn->kind) {
112 case QNUM_I64:
113 if (qn->u.i64 < 0) {
114 return false;
115 }
116 *val = qn->u.i64;
117 return true;
118 case QNUM_U64:
119 *val = qn->u.u64;
120 return true;
121 case QNUM_DOUBLE:
122 return false;
123 }
124
125 assert(0);
126 return false;
127 }
128
129 /**
130 * qnum_get_uint(): Get an unsigned integer from the number
131 *
132 * assert() on failure.
133 */
134 uint64_t qnum_get_uint(const QNum *qn)
135 {
136 uint64_t val;
137 bool success = qnum_get_try_uint(qn, &val);
138 assert(success);
139 return val;
140 }
141
142 /**
143 * qnum_get_double(): Get a float representation of the number
144 *
145 * qnum_get_double() loses precision for integers beyond 53 bits.
146 */
147 double qnum_get_double(QNum *qn)
148 {
149 switch (qn->kind) {
150 case QNUM_I64:
151 return qn->u.i64;
152 case QNUM_U64:
153 return qn->u.u64;
154 case QNUM_DOUBLE:
155 return qn->u.dbl;
156 }
157
158 assert(0);
159 return 0.0;
160 }
161
162 char *qnum_to_string(QNum *qn)
163 {
164 char *buffer;
165 int len;
166
167 switch (qn->kind) {
168 case QNUM_I64:
169 return g_strdup_printf("%" PRId64, qn->u.i64);
170 case QNUM_U64:
171 return g_strdup_printf("%" PRIu64, qn->u.u64);
172 case QNUM_DOUBLE:
173 /* FIXME: snprintf() is locale dependent; but JSON requires
174 * numbers to be formatted as if in the C locale. Dependence
175 * on C locale is a pervasive issue in QEMU. */
176 /* FIXME: This risks printing Inf or NaN, which are not valid
177 * JSON values. */
178 /* FIXME: the default precision of 6 for %f often causes
179 * rounding errors; we should be using DBL_DECIMAL_DIG (17),
180 * and only rounding to a shorter number if the result would
181 * still produce the same floating point value. */
182 buffer = g_strdup_printf("%f" , qn->u.dbl);
183 len = strlen(buffer);
184 while (len > 0 && buffer[len - 1] == '0') {
185 len--;
186 }
187
188 if (len && buffer[len - 1] == '.') {
189 buffer[len - 1] = 0;
190 } else {
191 buffer[len] = 0;
192 }
193
194 return buffer;
195 }
196
197 assert(0);
198 return NULL;
199 }
200
201 /**
202 * qnum_is_equal(): Test whether the two QNums are equal
203 *
204 * Negative integers are never considered equal to unsigned integers,
205 * but positive integers in the range [0, INT64_MAX] are considered
206 * equal independently of whether the QNum's kind is i64 or u64.
207 *
208 * Doubles are never considered equal to integers.
209 */
210 bool qnum_is_equal(const QObject *x, const QObject *y)
211 {
212 QNum *num_x = qobject_to(QNum, x);
213 QNum *num_y = qobject_to(QNum, y);
214
215 switch (num_x->kind) {
216 case QNUM_I64:
217 switch (num_y->kind) {
218 case QNUM_I64:
219 /* Comparison in native int64_t type */
220 return num_x->u.i64 == num_y->u.i64;
221 case QNUM_U64:
222 /* Implicit conversion of x to uin64_t, so we have to
223 * check its sign before */
224 return num_x->u.i64 >= 0 && num_x->u.i64 == num_y->u.u64;
225 case QNUM_DOUBLE:
226 return false;
227 }
228 abort();
229 case QNUM_U64:
230 switch (num_y->kind) {
231 case QNUM_I64:
232 return qnum_is_equal(y, x);
233 case QNUM_U64:
234 /* Comparison in native uint64_t type */
235 return num_x->u.u64 == num_y->u.u64;
236 case QNUM_DOUBLE:
237 return false;
238 }
239 abort();
240 case QNUM_DOUBLE:
241 switch (num_y->kind) {
242 case QNUM_I64:
243 case QNUM_U64:
244 return false;
245 case QNUM_DOUBLE:
246 /* Comparison in native double type */
247 return num_x->u.dbl == num_y->u.dbl;
248 }
249 abort();
250 }
251
252 abort();
253 }
254
255 /**
256 * qnum_destroy_obj(): Free all memory allocated by a
257 * QNum object
258 */
259 void qnum_destroy_obj(QObject *obj)
260 {
261 assert(obj != NULL);
262 g_free(qobject_to(QNum, obj));
263 }