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 | } |
264 | |