qobject/qnum.c

   1 /*
   2  * QNum Module
   3  *
   4  * Copyright (C) 2009 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <[email protected]>
   8  *  Anthony Liguori <[email protected]>
   9  *  Marc-André Lureau <[email protected]>
  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 "qemu-common.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     char *buffer;
 166     int len;
 167
 168     switch (qn->kind) {
 169     case QNUM_I64:
 170         return g_strdup_printf("%" PRId64, qn->u.i64);
 171     case QNUM_U64:
 172         return g_strdup_printf("%" PRIu64, qn->u.u64);
 173     case QNUM_DOUBLE:
 174         /* FIXME: snprintf() is locale dependent; but JSON requires
 175          * numbers to be formatted as if in the C locale. Dependence
 176          * on C locale is a pervasive issue in QEMU. */
 177         /* FIXME: This risks printing Inf or NaN, which are not valid
 178          * JSON values. */
 179         /* FIXME: the default precision of 6 for %f often causes
 180          * rounding errors; we should be using DBL_DECIMAL_DIG (17),
 181          * and only rounding to a shorter number if the result would
 182          * still produce the same floating point value.  */
 183         buffer = g_strdup_printf("%f" , qn->u.dbl);
 184         len = strlen(buffer);
 185         while (len > 0 && buffer[len - 1] == '0') {
 186             len--;
 187         }
 188
 189         if (len && buffer[len - 1] == '.') {
 190             buffer[len - 1] = 0;
 191         } else {
 192             buffer[len] = 0;
 193         }
 194
 195         return buffer;
 196     }
 197
 198     assert(0);
 199     return NULL;
 200 }
 201
 202 /**
 203  * qobject_to_qnum(): Convert a QObject into a QNum
 204  */
 205 QNum *qobject_to_qnum(const QObject *obj)
 206 {
 207     if (!obj || qobject_type(obj) != QTYPE_QNUM) {
 208         return NULL;
 209     }
 210     return container_of(obj, QNum, base);
 211 }
 212
 213 /**
 214  * qnum_is_equal(): Test whether the two QNums are equal
 215  *
 216  * Negative integers are never considered equal to unsigned integers,
 217  * but positive integers in the range [0, INT64_MAX] are considered
 218  * equal independently of whether the QNum's kind is i64 or u64.
 219  *
 220  * Doubles are never considered equal to integers.
 221  */
 222 bool qnum_is_equal(const QObject *x, const QObject *y)
 223 {
 224     QNum *num_x = qobject_to_qnum(x);
 225     QNum *num_y = qobject_to_qnum(y);
 226
 227     switch (num_x->kind) {
 228     case QNUM_I64:
 229         switch (num_y->kind) {
 230         case QNUM_I64:
 231             /* Comparison in native int64_t type */
 232             return num_x->u.i64 == num_y->u.i64;
 233         case QNUM_U64:
 234             /* Implicit conversion of x to uin64_t, so we have to
 235              * check its sign before */
 236             return num_x->u.i64 >= 0 && num_x->u.i64 == num_y->u.u64;
 237         case QNUM_DOUBLE:
 238             return false;
 239         }
 240         abort();
 241     case QNUM_U64:
 242         switch (num_y->kind) {
 243         case QNUM_I64:
 244             return qnum_is_equal(y, x);
 245         case QNUM_U64:
 246             /* Comparison in native uint64_t type */
 247             return num_x->u.u64 == num_y->u.u64;
 248         case QNUM_DOUBLE:
 249             return false;
 250         }
 251         abort();
 252     case QNUM_DOUBLE:
 253         switch (num_y->kind) {
 254         case QNUM_I64:
 255         case QNUM_U64:
 256             return false;
 257         case QNUM_DOUBLE:
 258             /* Comparison in native double type */
 259             return num_x->u.dbl == num_y->u.dbl;
 260         }
 261         abort();
 262     }
 263
 264     abort();
 265 }
 266
 267 /**
 268  * qnum_destroy_obj(): Free all memory allocated by a
 269  * QNum object
 270  */
 271 void qnum_destroy_obj(QObject *obj)
 272 {
 273     assert(obj != NULL);
 274     g_free(qobject_to_qnum(obj));
 275 }