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 }