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 #include "qobject-internal.h" 18 19 /** 20 * qnum_from_int(): Create a new QNum from an int64_t 21 * 22 * Return strong reference. 23 */ 24 QNum *qnum_from_int(int64_t value) 25 { 26 QNum *qn = g_new(QNum, 1); 27 28 qobject_init(QOBJECT(qn), QTYPE_QNUM); 29 qn->kind = QNUM_I64; 30 qn->u.i64 = value; 31 32 return qn; 33 } 34 35 /** 36 * qnum_from_uint(): Create a new QNum from an uint64_t 37 * 38 * Return strong reference. 39 */ 40 QNum *qnum_from_uint(uint64_t value) 41 { 42 QNum *qn = g_new(QNum, 1); 43 44 qobject_init(QOBJECT(qn), QTYPE_QNUM); 45 qn->kind = QNUM_U64; 46 qn->u.u64 = value; 47 48 return qn; 49 } 50 51 /** 52 * qnum_from_double(): Create a new QNum from a double 53 * 54 * Return strong reference. 55 */ 56 QNum *qnum_from_double(double value) 57 { 58 QNum *qn = g_new(QNum, 1); 59 60 qobject_init(QOBJECT(qn), QTYPE_QNUM); 61 qn->kind = QNUM_DOUBLE; 62 qn->u.dbl = value; 63 64 return qn; 65 } 66 67 /** 68 * qnum_get_try_int(): Get an integer representation of the number 69 * 70 * Return true on success. 71 */ 72 bool qnum_get_try_int(const QNum *qn, int64_t *val) 73 { 74 switch (qn->kind) { 75 case QNUM_I64: 76 *val = qn->u.i64; 77 return true; 78 case QNUM_U64: 79 if (qn->u.u64 > INT64_MAX) { 80 return false; 81 } 82 *val = qn->u.u64; 83 return true; 84 case QNUM_DOUBLE: 85 return false; 86 } 87 88 assert(0); 89 return false; 90 } 91 92 /** 93 * qnum_get_int(): Get an integer representation of the number 94 * 95 * assert() on failure. 96 */ 97 int64_t qnum_get_int(const QNum *qn) 98 { 99 int64_t val; 100 bool success = qnum_get_try_int(qn, &val); 101 assert(success); 102 return val; 103 } 104 105 /** 106 * qnum_get_uint(): Get an unsigned integer from the number 107 * 108 * Return true on success. 109 */ 110 bool qnum_get_try_uint(const QNum *qn, uint64_t *val) 111 { 112 switch (qn->kind) { 113 case QNUM_I64: 114 if (qn->u.i64 < 0) { 115 return false; 116 } 117 *val = qn->u.i64; 118 return true; 119 case QNUM_U64: 120 *val = qn->u.u64; 121 return true; 122 case QNUM_DOUBLE: 123 return false; 124 } 125 126 assert(0); 127 return false; 128 } 129 130 /** 131 * qnum_get_uint(): Get an unsigned integer from the number 132 * 133 * assert() on failure. 134 */ 135 uint64_t qnum_get_uint(const QNum *qn) 136 { 137 uint64_t val; 138 bool success = qnum_get_try_uint(qn, &val); 139 assert(success); 140 return val; 141 } 142 143 /** 144 * qnum_get_double(): Get a float representation of the number 145 * 146 * qnum_get_double() loses precision for integers beyond 53 bits. 147 */ 148 double qnum_get_double(QNum *qn) 149 { 150 switch (qn->kind) { 151 case QNUM_I64: 152 return qn->u.i64; 153 case QNUM_U64: 154 return qn->u.u64; 155 case QNUM_DOUBLE: 156 return qn->u.dbl; 157 } 158 159 assert(0); 160 return 0.0; 161 } 162 163 char *qnum_to_string(QNum *qn) 164 { 165 switch (qn->kind) { 166 case QNUM_I64: 167 return g_strdup_printf("%" PRId64, qn->u.i64); 168 case QNUM_U64: 169 return g_strdup_printf("%" PRIu64, qn->u.u64); 170 case QNUM_DOUBLE: 171 /* FIXME: g_strdup_printf() is locale dependent; but JSON requires 172 * numbers to be formatted as if in the C locale. Dependence 173 * on C locale is a pervasive issue in QEMU. */ 174 /* FIXME: This risks printing Inf or NaN, which are not valid 175 * JSON values. */ 176 /* 17 digits suffice for IEEE double */ 177 return g_strdup_printf("%.17g", qn->u.dbl); 178 } 179 180 assert(0); 181 return NULL; 182 } 183 184 /** 185 * qnum_is_equal(): Test whether the two QNums are equal 186 * 187 * Negative integers are never considered equal to unsigned integers, 188 * but positive integers in the range [0, INT64_MAX] are considered 189 * equal independently of whether the QNum's kind is i64 or u64. 190 * 191 * Doubles are never considered equal to integers. 192 */ 193 bool qnum_is_equal(const QObject *x, const QObject *y) 194 { 195 QNum *num_x = qobject_to(QNum, x); 196 QNum *num_y = qobject_to(QNum, y); 197 198 switch (num_x->kind) { 199 case QNUM_I64: 200 switch (num_y->kind) { 201 case QNUM_I64: 202 /* Comparison in native int64_t type */ 203 return num_x->u.i64 == num_y->u.i64; 204 case QNUM_U64: 205 /* Implicit conversion of x to uin64_t, so we have to 206 * check its sign before */ 207 return num_x->u.i64 >= 0 && num_x->u.i64 == num_y->u.u64; 208 case QNUM_DOUBLE: 209 return false; 210 } 211 abort(); 212 case QNUM_U64: 213 switch (num_y->kind) { 214 case QNUM_I64: 215 return qnum_is_equal(y, x); 216 case QNUM_U64: 217 /* Comparison in native uint64_t type */ 218 return num_x->u.u64 == num_y->u.u64; 219 case QNUM_DOUBLE: 220 return false; 221 } 222 abort(); 223 case QNUM_DOUBLE: 224 switch (num_y->kind) { 225 case QNUM_I64: 226 case QNUM_U64: 227 return false; 228 case QNUM_DOUBLE: 229 /* Comparison in native double type */ 230 return num_x->u.dbl == num_y->u.dbl; 231 } 232 abort(); 233 } 234 235 abort(); 236 } 237 238 /** 239 * qnum_destroy_obj(): Free all memory allocated by a 240 * QNum object 241 */ 242 void qnum_destroy_obj(QObject *obj) 243 { 244 assert(obj != NULL); 245 g_free(qobject_to(QNum, obj)); 246 } 247