Kick json_type_int and json_type_double out of struct json_object.

Clean up the code in json_object_new_* a bit by dropping unnecesary json_object_base variables.

diff --git a/json_object.c b/json_object.c
index f648c5c1717ebb967bac8958365f7491ccbb867e..53004485e59f3fdc3ca4e582e6dbcb04909231cf 100644 (file)
--- a/json_object.c
+++ b/json_object.c
@@ -94,20 +94,32 @@ static inline struct json_object_double *JC_DOUBLE(struct json_object_base *jso)
 {
        return (void *)jso;
 }
+static inline const struct json_object_double *JC_DOUBLE_C(const struct json_object_base *jso)
+{
+       return (const void *)jso;
+}
 static inline struct json_object_int *JC_INT(struct json_object_base *jso)
 {
        return (void *)jso;
 }
+static inline const struct json_object_int *JC_INT_C(const struct json_object_base *jso)
+{
+       return (const void *)jso;
+}
 static inline struct json_object_string *JC_STRING(struct json_object_base *jso)
 {
        return (void *)jso;
 }
+static inline const struct json_object_string *JC_STRING_C(const struct json_object_base *jso)
+{
+       return (const void *)jso;
+}
 
 #define JC_CONCAT(a,b) a##b
 #define JC_CONCAT3(a,b,c) a##b##c
 
 #define JSON_OBJECT_NEW(jtype, delete_fn) \
-       Xjson_object_new(JC_CONCAT(json_type_,jtype), \
+    (struct JC_CONCAT(json_object_,jtype) *)Xjson_object_new(JC_CONCAT(json_type_,jtype), \
                sizeof(struct JC_CONCAT(json_object_,jtype)), \
                &JC_CONCAT3(json_object_,jtype,_to_json_string), \
                (void *)delete_fn) // XAX drop cast
@@ -657,28 +669,24 @@ static void json_object_lh_entry_free(struct lh_entry *ent)
 
 static void json_object_object_delete(struct json_object_base *jso_base)
 {
-       struct json_object_object *jso = (struct json_object_object *)jso_base;
-       lh_table_free(jso->c_object);
+       lh_table_free(JC_OBJECT(jso_base)->c_object);
        Xjson_object_generic_delete(jso_base);
 }
 
 struct json_object *json_object_new_object(void)
 {
-       struct json_object_base *jso_base;
-       struct json_object_object *jso;
-       jso_base = JSON_OBJECT_NEW(object, &json_object_object_delete);
-       if (!jso_base)
+       struct json_object_object *jso = JSON_OBJECT_NEW(object, &json_object_object_delete);
+       if (!jso)
                return NULL;
-       jso = (struct json_object_object *)jso_base;
        jso->c_object =
            lh_kchar_table_new(JSON_OBJECT_DEF_HASH_ENTRIES, &json_object_lh_entry_free);
        if (!jso->c_object)
        {
-               Xjson_object_generic_delete(jso_base);
+               Xjson_object_generic_delete(&jso->base);
                errno = ENOMEM;
                return NULL;
        }
-       return PUBLIC(jso_base);
+       return PUBLIC(&jso->base);
 }
 
 struct lh_table *json_object_get_object(const struct json_object *jso)
@@ -805,14 +813,11 @@ static int json_object_boolean_to_json_string(struct json_object *jso, struct pr
 
 struct json_object *json_object_new_boolean(json_bool b)
 {
-       struct json_object_base *jso_base;
-       struct json_object_boolean *jso;
-       jso_base = JSON_OBJECT_NEW(boolean, &json_object_generic_delete);
-       if (!jso_base)
+       struct json_object_boolean *jso = JSON_OBJECT_NEW(boolean, &json_object_generic_delete);
+       if (!jso)
                return NULL;
-       jso = (struct json_object_boolean *)jso_base;
        jso->c_boolean = b;
-       return PUBLIC(jso_base);
+       return PUBLIC(&jso->base);
 }
 
 json_bool json_object_get_boolean(const struct json_object *jso)
@@ -823,15 +828,15 @@ json_bool json_object_get_boolean(const struct json_object *jso)
        {
 #define jso ((const struct json_object_base *)jso)
        case json_type_boolean: return JC_BOOL_C(jso)->c_boolean;
-#undef jso
        case json_type_int:
-               switch (jso->o.c_int.cint_type)
+               switch (JC_INT_C(jso)->cint_type)
                {
-               case json_object_int_type_int64: return (jso->o.c_int.cint.c_int64 != 0);
-               case json_object_int_type_uint64: return (jso->o.c_int.cint.c_uint64 != 0);
+               case json_object_int_type_int64: return (JC_INT_C(jso)->cint.c_int64 != 0);
+               case json_object_int_type_uint64: return (JC_INT_C(jso)->cint.c_uint64 != 0);
                default: json_abort("invalid cint_type");
                }
-       case json_type_double: return (jso->o.c_double != 0);
+       case json_type_double: return (JC_DOUBLE_C(jso)->c_double != 0);
+#undef jso
        case json_type_string: return (jso->o.c_string.len != 0);
        default: return 0;
        }
@@ -847,60 +852,60 @@ int json_object_set_boolean(struct json_object *jso, json_bool new_value)
 #undef jso
 }
 
-// XAX ------------------------------ start unconverted code:
 /* json_object_int */
 
 static int json_object_int_to_json_string(struct json_object *jso, struct printbuf *pb, int level,
                                           int flags)
 {
+#define jso ((struct json_object_base *)jso)
        /* room for 19 digits, the sign char, and a null term */
        char sbuf[21];
-       if (jso->o.c_int.cint_type == json_object_int_type_int64)
-               snprintf(sbuf, sizeof(sbuf), "%" PRId64, jso->o.c_int.cint.c_int64);
+       if (JC_INT(jso)->cint_type == json_object_int_type_int64)
+               snprintf(sbuf, sizeof(sbuf), "%" PRId64, JC_INT(jso)->cint.c_int64);
        else
-               snprintf(sbuf, sizeof(sbuf), "%" PRIu64, jso->o.c_int.cint.c_uint64);
+               snprintf(sbuf, sizeof(sbuf), "%" PRIu64, JC_INT(jso)->cint.c_uint64);
        return printbuf_memappend(pb, sbuf, strlen(sbuf));
+#undef jso
 }
 
 struct json_object *json_object_new_int(int32_t i)
 {
-       struct json_object *jso = json_object_new(json_type_int);
-       if (!jso)
-               return NULL;
-       jso->_to_json_string = &json_object_int_to_json_string;
-       jso->o.c_int.cint.c_int64 = i;
-       jso->o.c_int.cint_type = json_object_int_type_int64;
-       return jso;
+       return json_object_new_int64(i);
 }
 
 int32_t json_object_get_int(const struct json_object *jso)
 {
+#define jso ((const struct json_object_base *)jso)
        int64_t cint64;
+       double cdouble;
        enum json_type o_type;
 
        if (!jso)
                return 0;
 
        o_type = jso->o_type;
-       if (jso->o.c_int.cint_type == json_object_int_type_int64)
+       if (o_type == json_type_int)
        {
-               cint64 = jso->o.c_int.cint.c_int64;
-       }
-       else
-       {
-               if (jso->o.c_int.cint.c_uint64 >= INT64_MAX)
-                       cint64 = INT64_MAX;
+               const struct json_object_int *jsoint = JC_INT_C(jso);
+               if (jsoint->cint_type == json_object_int_type_int64)
+               {
+                       cint64 = jsoint->cint.c_int64;
+               }
                else
-                       cint64 = (int64_t)jso->o.c_int.cint.c_uint64;
+               {
+                       if (jsoint->cint.c_uint64 >= INT64_MAX)
+                               cint64 = INT64_MAX;
+                       else
+                               cint64 = (int64_t)jsoint->cint.c_uint64;
+               }
        }
-
-       if (o_type == json_type_string)
+       else if (o_type == json_type_string)
        {
                /*
                 * Parse strings into 64-bit numbers, then use the
                 * 64-to-32-bit number handling below.
                 */
-               if (json_parse_int64(get_string_component(jso), &cint64) != 0)
+               if (json_parse_int64(get_string_component(PUBLIC_C(jso)), &cint64) != 0)
                        return 0; /* whoops, it didn't work. */
                o_type = json_type_int;
        }
@@ -915,16 +920,16 @@ int32_t json_object_get_int(const struct json_object *jso)
                        return INT32_MAX;
                return (int32_t)cint64;
        case json_type_double:
-               if (jso->o.c_double <= INT32_MIN)
+               cdouble = JC_DOUBLE_C(jso)->c_double;
+               if (cdouble <= INT32_MIN)
                        return INT32_MIN;
-               if (jso->o.c_double >= INT32_MAX)
+               if (cdouble >= INT32_MAX)
                        return INT32_MAX;
-               return (int32_t)jso->o.c_double;
-#define jso ((const struct json_object_base *)jso)
+               return (int32_t)cdouble;
        case json_type_boolean: return JC_BOOL_C(jso)->c_boolean;
-#undef jso
        default: return 0;
        }
+#undef jso
 }
 
 int json_object_set_int(struct json_object *jso, int new_value)
@@ -934,28 +939,27 @@ int json_object_set_int(struct json_object *jso, int new_value)
 
 struct json_object *json_object_new_int64(int64_t i)
 {
-       struct json_object *jso = json_object_new(json_type_int);
+       struct json_object_int *jso = JSON_OBJECT_NEW(int, &json_object_generic_delete);
        if (!jso)
                return NULL;
-       jso->_to_json_string = &json_object_int_to_json_string;
-       jso->o.c_int.cint.c_int64 = i;
-       jso->o.c_int.cint_type = json_object_int_type_int64;
-       return jso;
+       jso->cint.c_int64 = i;
+       jso->cint_type = json_object_int_type_int64;
+       return PUBLIC(&jso->base);
 }
 
 struct json_object *json_object_new_uint64(uint64_t i)
 {
-       struct json_object *jso = json_object_new(json_type_int);
+       struct json_object_int *jso = JSON_OBJECT_NEW(int, &json_object_generic_delete);
        if (!jso)
                return NULL;
-       jso->_to_json_string = &json_object_int_to_json_string;
-       jso->o.c_int.cint.c_uint64 = i;
-       jso->o.c_int.cint_type = json_object_int_type_uint64;
-       return jso;
+       jso->cint.c_uint64 = i;
+       jso->cint_type = json_object_int_type_uint64;
+       return PUBLIC(&jso->base);
 }
 
 int64_t json_object_get_int64(const struct json_object *jso)
 {
+#define jso ((const struct json_object_base *)jso)
        int64_t cint;
 
        if (!jso)
@@ -963,36 +967,39 @@ int64_t json_object_get_int64(const struct json_object *jso)
        switch (jso->o_type)
        {
        case json_type_int:
-               switch (jso->o.c_int.cint_type)
+       {
+               const struct json_object_int *jsoint = JC_INT_C(jso);
+               switch (jsoint->cint_type)
                {
-               case json_object_int_type_int64: return jso->o.c_int.cint.c_int64;
+               case json_object_int_type_int64: return jsoint->cint.c_int64;
                case json_object_int_type_uint64:
-                       if (jso->o.c_int.cint.c_uint64 >= INT64_MAX)
+                       if (jsoint->cint.c_uint64 >= INT64_MAX)
                                return INT64_MAX;
-                       return (int64_t)jso->o.c_int.cint.c_uint64;
+                       return (int64_t)jsoint->cint.c_uint64;
                default: json_abort("invalid cint_type");
                }
+       }
        case json_type_double:
                // INT64_MAX can't be exactly represented as a double
                // so cast to tell the compiler it's ok to round up.
-               if (jso->o.c_double >= (double)INT64_MAX)
+               if (JC_DOUBLE_C(jso)->c_double >= (double)INT64_MAX)
                        return INT64_MAX;
-               if (jso->o.c_double <= INT64_MIN)
+               if (JC_DOUBLE_C(jso)->c_double <= INT64_MIN)
                        return INT64_MIN;
-               return (int64_t)jso->o.c_double;
-#define jso ((const struct json_object_base *)jso)
+               return (int64_t)JC_DOUBLE_C(jso)->c_double;
        case json_type_boolean: return JC_BOOL_C(jso)->c_boolean;
-#undef jso
        case json_type_string:
-               if (json_parse_int64(get_string_component(jso), &cint) == 0)
+               if (json_parse_int64(get_string_component(PUBLIC_C(jso)), &cint) == 0)
                        return cint;
                /* FALLTHRU */
        default: return 0;
        }
+#undef jso
 }
 
 uint64_t json_object_get_uint64(const struct json_object *jso)
 {
+#define jso ((const struct json_object_base *)jso)
        uint64_t cuint;
 
        if (!jso)
@@ -1000,95 +1007,105 @@ uint64_t json_object_get_uint64(const struct json_object *jso)
        switch (jso->o_type)
        {
        case json_type_int:
-               switch (jso->o.c_int.cint_type)
+       {
+               const struct json_object_int *jsoint = JC_INT_C(jso);
+               switch (jsoint->cint_type)
                {
                case json_object_int_type_int64:
-                       if (jso->o.c_int.cint.c_int64 < 0)
+                       if (jsoint->cint.c_int64 < 0)
                                return 0;
-                       return (uint64_t)jso->o.c_int.cint.c_int64;
-               case json_object_int_type_uint64: return jso->o.c_int.cint.c_uint64;
+                       return (uint64_t)jsoint->cint.c_int64;
+               case json_object_int_type_uint64: return jsoint->cint.c_uint64;
                default: json_abort("invalid cint_type");
                }
+       }
        case json_type_double:
                // UINT64_MAX can't be exactly represented as a double
                // so cast to tell the compiler it's ok to round up.
-               if (jso->o.c_double >= (double)UINT64_MAX)
+               if (JC_DOUBLE_C(jso)->c_double >= (double)UINT64_MAX)
                        return UINT64_MAX;
-               if (jso->o.c_double < 0)
+               if (JC_DOUBLE_C(jso)->c_double < 0)
                        return 0;
-               return (uint64_t)jso->o.c_double;
-#define jso ((const struct json_object_base *)jso)
+               return (uint64_t)JC_DOUBLE_C(jso)->c_double;
        case json_type_boolean: return JC_BOOL_C(jso)->c_boolean;
-#undef jso
        case json_type_string:
-               if (json_parse_uint64(get_string_component(jso), &cuint) == 0)
+               if (json_parse_uint64(get_string_component(PUBLIC_C(jso)), &cuint) == 0)
                        return cuint;
                /* FALLTHRU */
        default: return 0;
        }
+#undef jso
 }
 
 int json_object_set_int64(struct json_object *jso, int64_t new_value)
 {
+#define jso ((struct json_object_base *)jso)
        if (!jso || jso->o_type != json_type_int)
                return 0;
-       jso->o.c_int.cint.c_int64 = new_value;
-       jso->o.c_int.cint_type = json_object_int_type_int64;
+       JC_INT(jso)->cint.c_int64 = new_value;
+       JC_INT(jso)->cint_type = json_object_int_type_int64;
        return 1;
+#undef jso
 }
 
 int json_object_set_uint64(struct json_object *jso, uint64_t new_value)
 {
+#define jso ((struct json_object_base *)jso)
        if (!jso || jso->o_type != json_type_int)
                return 0;
-       jso->o.c_int.cint.c_uint64 = new_value;
-       jso->o.c_int.cint_type = json_object_int_type_uint64;
+       JC_INT(jso)->cint.c_uint64 = new_value;
+       JC_INT(jso)->cint_type = json_object_int_type_uint64;
        return 1;
+#undef jso
 }
 
 int json_object_int_inc(struct json_object *jso, int64_t val)
 {
+#define jso ((struct json_object_base *)jso)
+       struct json_object_int *jsoint;
        if (!jso || jso->o_type != json_type_int)
                return 0;
-       switch (jso->o.c_int.cint_type)
+       jsoint = JC_INT(jso);
+       switch (jsoint->cint_type)
        {
        case json_object_int_type_int64:
-               if (val > 0 && jso->o.c_int.cint.c_int64 > INT64_MAX - val)
+               if (val > 0 && jsoint->cint.c_int64 > INT64_MAX - val)
                {
-                       jso->o.c_int.cint.c_uint64 =
-                           (uint64_t)jso->o.c_int.cint.c_int64 + (uint64_t)val;
-                       jso->o.c_int.cint_type = json_object_int_type_uint64;
+                       jsoint->cint.c_uint64 =
+                           (uint64_t)jsoint->cint.c_int64 + (uint64_t)val;
+                       jsoint->cint_type = json_object_int_type_uint64;
                }
-               else if (val < 0 && jso->o.c_int.cint.c_int64 < INT64_MIN - val)
+               else if (val < 0 && jsoint->cint.c_int64 < INT64_MIN - val)
                {
-                       jso->o.c_int.cint.c_int64 = INT64_MIN;
+                       jsoint->cint.c_int64 = INT64_MIN;
                }
                else
                {
-                       jso->o.c_int.cint.c_int64 += val;
+                       jsoint->cint.c_int64 += val;
                }
                return 1;
        case json_object_int_type_uint64:
-               if (val > 0 && jso->o.c_int.cint.c_uint64 > UINT64_MAX - (uint64_t)val)
+               if (val > 0 && jsoint->cint.c_uint64 > UINT64_MAX - (uint64_t)val)
                {
-                       jso->o.c_int.cint.c_uint64 = UINT64_MAX;
+                       jsoint->cint.c_uint64 = UINT64_MAX;
                }
-               else if (val < 0 && jso->o.c_int.cint.c_uint64 < (uint64_t)(-val))
+               else if (val < 0 && jsoint->cint.c_uint64 < (uint64_t)(-val))
                {
-                       jso->o.c_int.cint.c_int64 = (int64_t)jso->o.c_int.cint.c_uint64 + val;
-                       jso->o.c_int.cint_type = json_object_int_type_int64;
+                       jsoint->cint.c_int64 = (int64_t)jsoint->cint.c_uint64 + val;
+                       jsoint->cint_type = json_object_int_type_int64;
                }
-               else if (val < 0 && jso->o.c_int.cint.c_uint64 >= (uint64_t)(-val))
+               else if (val < 0 && jsoint->cint.c_uint64 >= (uint64_t)(-val))
                {
-                       jso->o.c_int.cint.c_uint64 -= (uint64_t)(-val);
+                       jsoint->cint.c_uint64 -= (uint64_t)(-val);
                }
                else
                {
-                       jso->o.c_int.cint.c_uint64 += val;
+                       jsoint->cint.c_uint64 += val;
                }
                return 1;
        default: json_abort("invalid cint_type");
        }
+#undef jso
 }
 
 /* json_object_double */
@@ -1140,6 +1157,8 @@ int json_c_set_serialization_double_format(const char *double_format, int global
 static int json_object_double_to_json_string_format(struct json_object *jso, struct printbuf *pb,
                                                     int level, int flags, const char *format)
 {
+#define jso ((struct json_object_base *)jso)
+       struct json_object_double *jsodbl = JC_DOUBLE(jso);
        char buf[128], *p, *q;
        int size;
        /* Although JSON RFC does not support
@@ -1147,13 +1166,13 @@ static int json_object_double_to_json_string_format(struct json_object *jso, str
         * ECMA 262 section 9.8.1 defines
         * how to handle these cases as strings
         */
-       if (isnan(jso->o.c_double))
+       if (isnan(jsodbl->c_double))
        {
                size = snprintf(buf, sizeof(buf), "NaN");
        }
-       else if (isinf(jso->o.c_double))
+       else if (isinf(jsodbl->c_double))
        {
-               if (jso->o.c_double > 0)
+               if (jsodbl->c_double > 0)
                        size = snprintf(buf, sizeof(buf), "Infinity");
                else
                        size = snprintf(buf, sizeof(buf), "-Infinity");
@@ -1176,7 +1195,7 @@ static int json_object_double_to_json_string_format(struct json_object *jso, str
                        else
                                format = std_format;
                }
-               size = snprintf(buf, sizeof(buf), format, jso->o.c_double);
+               size = snprintf(buf, sizeof(buf), format, jsodbl->c_double);
 
                if (size < 0)
                        return -1;
@@ -1228,29 +1247,34 @@ static int json_object_double_to_json_string_format(struct json_object *jso, str
                size = sizeof(buf) - 1;
        printbuf_memappend(pb, buf, size);
        return size;
+#undef jso
 }
 
 static int json_object_double_to_json_string_default(struct json_object *jso, struct printbuf *pb,
                                                      int level, int flags)
 {
-       return json_object_double_to_json_string_format(jso, pb, level, flags, NULL);
+#define jso ((struct json_object_base *)jso)
+       return json_object_double_to_json_string_format(PUBLIC(jso), pb, level, flags, NULL);
+#undef jso
 }
 
 int json_object_double_to_json_string(struct json_object *jso, struct printbuf *pb, int level,
                                       int flags)
 {
-       return json_object_double_to_json_string_format(jso, pb, level, flags,
+#define jso ((struct json_object_base *)jso)
+       return json_object_double_to_json_string_format(PUBLIC(jso), pb, level, flags,
                                                        (const char *)jso->_userdata);
+#undef jso
 }
 
 struct json_object *json_object_new_double(double d)
 {
-       struct json_object *jso = json_object_new(json_type_double);
+       struct json_object_double *jso = JSON_OBJECT_NEW(double, &json_object_generic_delete);
        if (!jso)
                return NULL;
-       jso->_to_json_string = &json_object_double_to_json_string_default;
-       jso->o.c_double = d;
-       return jso;
+       jso->base._to_json_string = &json_object_double_to_json_string_default;
+       jso->c_double = d;
+       return PUBLIC(&jso->base);
 }
 
 struct json_object *json_object_new_double_s(double d, const char *ds)
@@ -1286,9 +1310,21 @@ static int _json_object_userdata_to_json_string(struct json_object *jso, struct
 int json_object_userdata_to_json_string(struct json_object *jso, struct printbuf *pb, int level,
                                         int flags)
 {
+       // XAX old code compat, remove this
+       if (!jso->newold)
+       {
+               int userdata_len = strlen((const char *)jso->_userdata);
+               printbuf_memappend(pb, (const char *)jso->_userdata, userdata_len);
+               return userdata_len;
+       }
+       else
+       {
+#define jso ((const struct json_object_base *)jso)
        int userdata_len = strlen((const char *)jso->_userdata);
        printbuf_memappend(pb, (const char *)jso->_userdata, userdata_len);
        return userdata_len;
+#undef jso
+       }
 }
 
 void json_object_free_userdata(struct json_object *jso, void *userdata)
@@ -1298,6 +1334,7 @@ void json_object_free_userdata(struct json_object *jso, void *userdata)
 
 double json_object_get_double(const struct json_object *jso)
 {
+#define jso ((const struct json_object_base *)jso)
        double cdouble;
        char *errPtr = NULL;
 
@@ -1305,23 +1342,21 @@ double json_object_get_double(const struct json_object *jso)
                return 0.0;
        switch (jso->o_type)
        {
-       case json_type_double: return jso->o.c_double;
+       case json_type_double: return JC_DOUBLE_C(jso)->c_double;
        case json_type_int:
-               switch (jso->o.c_int.cint_type)
+               switch (JC_INT_C(jso)->cint_type)
                {
-               case json_object_int_type_int64: return jso->o.c_int.cint.c_int64;
-               case json_object_int_type_uint64: return jso->o.c_int.cint.c_uint64;
+               case json_object_int_type_int64: return JC_INT_C(jso)->cint.c_int64;
+               case json_object_int_type_uint64: return JC_INT_C(jso)->cint.c_uint64;
                default: json_abort("invalid cint_type");
                }
-#define jso ((const struct json_object_base *)jso)
        case json_type_boolean: return JC_BOOL_C(jso)->c_boolean;
-#undef jso
        case json_type_string:
                errno = 0;
-               cdouble = strtod(get_string_component(jso), &errPtr);
+               cdouble = strtod(get_string_component(PUBLIC_C(jso)), &errPtr);
 
                /* if conversion stopped at the first character, return 0.0 */
-               if (errPtr == get_string_component(jso))
+               if (errPtr == get_string_component(PUBLIC_C(jso)))
                {
                        errno = EINVAL;
                        return 0.0;
@@ -1354,16 +1389,19 @@ double json_object_get_double(const struct json_object *jso)
                return cdouble;
        default: errno = EINVAL; return 0.0;
        }
+#undef jso
 }
 
 int json_object_set_double(struct json_object *jso, double new_value)
 {
+#define jso ((struct json_object_base *)jso)
        if (!jso || jso->o_type != json_type_double)
                return 0;
-       jso->o.c_double = new_value;
+       JC_DOUBLE(jso)->c_double = new_value;
        if (jso->_to_json_string == &_json_object_userdata_to_json_string)
-               json_object_set_serializer(jso, NULL, NULL, NULL);
+               json_object_set_serializer(PUBLIC(jso), NULL, NULL, NULL);
        return 1;
+#undef jso
 }
 
 /* json_object_string */
@@ -1550,19 +1588,16 @@ static void json_object_array_delete(struct json_object *jso)
 
 struct json_object *json_object_new_array(void)
 {
-       struct json_object_base *jso_base;
-       struct json_object_array *jso;
-       jso_base = JSON_OBJECT_NEW(array, &json_object_array_delete);
-       if (!jso_base)
+       struct json_object_array *jso = JSON_OBJECT_NEW(array, &json_object_array_delete);
+       if (!jso)
                return NULL;
-       jso = (struct json_object_array *)jso_base;
        jso->c_array = array_list_new(&json_object_array_entry_free);
        if (jso->c_array == NULL)
        {
                free(jso);
                return NULL;
        }
-       return PUBLIC(jso_base);
+       return PUBLIC(&jso->base);
 }
 
 struct array_list *json_object_get_array(const struct json_object *jso)
@@ -1675,8 +1710,7 @@ static int json_object_all_values_equal(struct json_object_base *jso1, struct js
        /* Iterate over jso1 keys and see if they exist and are equal in jso2 */
        json_object_object_foreachC(jso1, iter)
        {
-               struct json_object_object *jso2_object = (struct json_object_object *)jso2;
-               if (!lh_table_lookup_ex(jso2_object->c_object, (void *)iter.key, (void **)(void *)&sub))
+               if (!lh_table_lookup_ex(JC_OBJECT(jso2)->c_object, (void *)iter.key, (void **)(void *)&sub))
                        return 0;
                if (!json_object_equal(iter.val, sub))
                        return 0;
@@ -1685,8 +1719,7 @@ static int json_object_all_values_equal(struct json_object_base *jso1, struct js
        /* Iterate over jso2 keys to see if any exist that are not in jso1 */
        json_object_object_foreachC(jso2, iter)
        {
-               struct json_object_object *jso1_object = (struct json_object_object *)jso1;
-               if (!lh_table_lookup_ex(jso1_object->c_object, (void *)iter.key, (void **)(void *)&sub))
+               if (!lh_table_lookup_ex(JC_OBJECT(jso1)->c_object, (void *)iter.key, (void **)(void *)&sub))
                        return 0;
        }
 
@@ -1708,9 +1741,10 @@ static int Xjson_object_equal(struct json_object *jso1, struct json_object *jso2
        {
        case json_type_boolean: assert(0); //return (jso1->o.c_boolean == jso2->o.c_boolean);
 
-       case json_type_double: return (jso1->o.c_double == jso2->o.c_double);
+       case json_type_double: assert(0); // return (jso1->o.c_double == jso2->o.c_double);
 
-       case json_type_int:
+       case json_type_int: assert(0);
+       /*
                if (jso1->o.c_int.cint_type == json_object_int_type_int64)
                {
                        if (jso2->o.c_int.cint_type == json_object_int_type_int64)
@@ -1726,6 +1760,7 @@ static int Xjson_object_equal(struct json_object *jso1, struct json_object *jso2
                if (jso2->o.c_int.cint.c_int64 < 0)
                        return 0;
                return (jso1->o.c_int.cint.c_uint64 == (uint64_t)jso2->o.c_int.cint.c_int64);
+       */
 
        case json_type_string:
                return (jso1->o.c_string.len == jso2->o.c_string.len &&
@@ -1870,22 +1905,22 @@ int json_c_shallow_copy_default(json_object *src, json_object *parent, const cha
        {
 #define src ((struct json_object_base *)src)
        case json_type_boolean: *dst = json_object_new_boolean(JC_BOOL(src)->c_boolean); break;
-#undef src
 
-       case json_type_double: *dst = json_object_new_double(src->o.c_double); break;
+       case json_type_double: *dst = json_object_new_double(JC_DOUBLE(src)->c_double); break;
 
        case json_type_int:
-               switch (src->o.c_int.cint_type)
+               switch (JC_INT(src)->cint_type)
                {
                case json_object_int_type_int64:
-                       *dst = json_object_new_int64(src->o.c_int.cint.c_int64);
+                       *dst = json_object_new_int64(JC_INT(src)->cint.c_int64);
                        break;
                case json_object_int_type_uint64:
-                       *dst = json_object_new_uint64(src->o.c_int.cint.c_uint64);
+                       *dst = json_object_new_uint64(JC_INT(src)->cint.c_uint64);
                        break;
                default: json_abort("invalid cint_type");
                }
                break;
+#undef src
 
        case json_type_string: *dst = json_object_new_string(get_string_component(src)); break;
 

diff --git a/json_object_private.h b/json_object_private.h
index 0f6a4f8a933ffb85ac98d421777419dcfce0678a..5ea865c30af117ae34385a6ae2ab67c02db00352 100644 (file)
--- a/json_object_private.h
+++ b/json_object_private.h
@@ -68,7 +68,7 @@ struct json_object_boolean
 struct json_object_double
 {
        struct json_object_base base;
-       json_bool c_double;
+       double c_double;
 };
 struct json_object_int
 {
@@ -97,16 +97,6 @@ struct json_object
        struct printbuf *_pb;
        union data
        {
-               double c_double;
-               struct
-               {
-                       union
-                       {
-                               int64_t c_int64;
-                               uint64_t c_uint64;
-                       } cint;
-                       enum json_object_int_type cint_type;
-               } c_int;
                struct
                {
                        union

diff --git a/tests/test_double_serializer.c b/tests/test_double_serializer.c
index 8b2487a3d6e5b2a3898f5e9ce550d2f5269dd3b7..98f6dd91782b2565c4b4045cde10b8c8dd0465fa 100644 (file)
--- a/tests/test_double_serializer.c
+++ b/tests/test_double_serializer.c
@@ -20,7 +20,7 @@ int main()
        printf("obj.to_string(standard)=%s\n", json_object_to_json_string(obj));
 
        printf("Test default serializer with custom userdata:\n");
-       obj->_userdata = udata;
+       ((struct json_object_base *)obj)->_userdata = udata;
        printf("obj.to_string(userdata)=%s\n", json_object_to_json_string(obj));
 
        printf("Test explicit serializer with custom userdata:\n");