qemu

qnum.c (5217B)

---

 /*
  * QNum Module
  *
  * Copyright (C) 2009 Red Hat Inc.
  *
  * Authors:
  *  Luiz Capitulino <lcapitulino@redhat.com>
  *  Anthony Liguori <aliguori@us.ibm.com>
  *  Marc-André Lureau <marcandre.lureau@redhat.com>
  *
  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  * See the COPYING.LIB file in the top-level directory.
  */
 
 #include "qemu/osdep.h"
 #include "qapi/qmp/qnum.h"
 #include "qobject-internal.h"
 
 /**
  * qnum_from_int(): Create a new QNum from an int64_t
  *
  * Return strong reference.
  */
 QNum *qnum_from_int(int64_t value)
 {
     QNum *qn = g_new(QNum, 1);
 
     qobject_init(QOBJECT(qn), QTYPE_QNUM);
     qn->kind = QNUM_I64;
     qn->u.i64 = value;
 
     return qn;
 }
 
 /**
  * qnum_from_uint(): Create a new QNum from an uint64_t
  *
  * Return strong reference.
  */
 QNum *qnum_from_uint(uint64_t value)
 {
     QNum *qn = g_new(QNum, 1);
 
     qobject_init(QOBJECT(qn), QTYPE_QNUM);
     qn->kind = QNUM_U64;
     qn->u.u64 = value;
 
     return qn;
 }
 
 /**
  * qnum_from_double(): Create a new QNum from a double
  *
  * Return strong reference.
  */
 QNum *qnum_from_double(double value)
 {
     QNum *qn = g_new(QNum, 1);
 
     qobject_init(QOBJECT(qn), QTYPE_QNUM);
     qn->kind = QNUM_DOUBLE;
     qn->u.dbl = value;
 
     return qn;
 }
 
 /**
  * qnum_get_try_int(): Get an integer representation of the number
  *
  * Return true on success.
  */
 bool qnum_get_try_int(const QNum *qn, int64_t *val)
 {
     switch (qn->kind) {
     case QNUM_I64:
         *val = qn->u.i64;
         return true;
     case QNUM_U64:
         if (qn->u.u64 > INT64_MAX) {
             return false;
         }
         *val = qn->u.u64;
         return true;
     case QNUM_DOUBLE:
         return false;
     }
 
     assert(0);
     return false;
 }
 
 /**
  * qnum_get_int(): Get an integer representation of the number
  *
  * assert() on failure.
  */
 int64_t qnum_get_int(const QNum *qn)
 {
     int64_t val;
     bool success = qnum_get_try_int(qn, &val);
     assert(success);
     return val;
 }
 
 /**
  * qnum_get_uint(): Get an unsigned integer from the number
  *
  * Return true on success.
  */
 bool qnum_get_try_uint(const QNum *qn, uint64_t *val)
 {
     switch (qn->kind) {
     case QNUM_I64:
         if (qn->u.i64 < 0) {
             return false;
         }
         *val = qn->u.i64;
         return true;
     case QNUM_U64:
         *val = qn->u.u64;
         return true;
     case QNUM_DOUBLE:
         return false;
     }
 
     assert(0);
     return false;
 }
 
 /**
  * qnum_get_uint(): Get an unsigned integer from the number
  *
  * assert() on failure.
  */
 uint64_t qnum_get_uint(const QNum *qn)
 {
     uint64_t val;
     bool success = qnum_get_try_uint(qn, &val);
     assert(success);
     return val;
 }
 
 /**
  * qnum_get_double(): Get a float representation of the number
  *
  * qnum_get_double() loses precision for integers beyond 53 bits.
  */
 double qnum_get_double(QNum *qn)
 {
     switch (qn->kind) {
     case QNUM_I64:
         return qn->u.i64;
     case QNUM_U64:
         return qn->u.u64;
     case QNUM_DOUBLE:
         return qn->u.dbl;
     }
 
     assert(0);
     return 0.0;
 }
 
 char *qnum_to_string(QNum *qn)
 {
     switch (qn->kind) {
     case QNUM_I64:
         return g_strdup_printf("%" PRId64, qn->u.i64);
     case QNUM_U64:
         return g_strdup_printf("%" PRIu64, qn->u.u64);
     case QNUM_DOUBLE:
         /* 17 digits suffice for IEEE double */
         return g_strdup_printf("%.17g", qn->u.dbl);
     }
 
     assert(0);
     return NULL;
 }
 
 /**
  * qnum_is_equal(): Test whether the two QNums are equal
  *
  * Negative integers are never considered equal to unsigned integers,
  * but positive integers in the range [0, INT64_MAX] are considered
  * equal independently of whether the QNum's kind is i64 or u64.
  *
  * Doubles are never considered equal to integers.
  */
 bool qnum_is_equal(const QObject *x, const QObject *y)
 {
     QNum *num_x = qobject_to(QNum, x);
     QNum *num_y = qobject_to(QNum, y);
 
     switch (num_x->kind) {
     case QNUM_I64:
         switch (num_y->kind) {
         case QNUM_I64:
             /* Comparison in native int64_t type */
             return num_x->u.i64 == num_y->u.i64;
         case QNUM_U64:
             /* Implicit conversion of x to uin64_t, so we have to
              * check its sign before */
             return num_x->u.i64 >= 0 && num_x->u.i64 == num_y->u.u64;
         case QNUM_DOUBLE:
             return false;
         }
         abort();
     case QNUM_U64:
         switch (num_y->kind) {
         case QNUM_I64:
             return qnum_is_equal(y, x);
         case QNUM_U64:
             /* Comparison in native uint64_t type */
             return num_x->u.u64 == num_y->u.u64;
         case QNUM_DOUBLE:
             return false;
         }
         abort();
     case QNUM_DOUBLE:
         switch (num_y->kind) {
         case QNUM_I64:
         case QNUM_U64:
             return false;
         case QNUM_DOUBLE:
             /* Comparison in native double type */
             return num_x->u.dbl == num_y->u.dbl;
         }
         abort();
     }
 
     abort();
 }
 
 /**
  * qnum_destroy_obj(): Free all memory allocated by a
  * QNum object
  */
 void qnum_destroy_obj(QObject *obj)
 {
     assert(obj != NULL);
     g_free(qobject_to(QNum, obj));
 }
 
 void qnum_unref(QNum *q)
 {
     qobject_unref(q);
 }