oj 3.13.17 → 3.16.3

data/ext/oj/object.c

@@ -67,9 +67,9 @@ static VALUE str_to_value(ParseInfo pi, const char *str, size_t len, const char
 
 // The much faster approach (4x faster)
 static int parse_num(const char *str, const char *end, int cnt) {
-    int n = 0;
+    int  n = 0;
     char c;
-    int i;
+    int  i;
 
     for (i = cnt; 0 < i; i--, str++) {
         c = *str;
@@ -83,9 +83,10 @@ static int parse_num(const char *str, const char *end, int cnt) {
 
 VALUE
 oj_parse_xml_time(const char *str, int len) {
-    VALUE args[8];
-    const char *end = str + len;
-    int n;
+    VALUE       args[7];
+    const char *end  = str + len;
+    const char *orig = str;
+    int         n;
 
     // year
     if (0 > (n = parse_num(str, end, 4))) {
@@ -144,7 +145,9 @@ oj_parse_xml_time(const char *str, int len) {
         char c = *str++;
 
         if ('.' == c) {
-            long long nsec = 0;
+            unsigned long long       num            = 0;
+            unsigned long long       den            = 1;
+            const unsigned long long last_den_limit = ULLONG_MAX / 10;
 
             for (; str < end; str++) {
                 c = *str;
@@ -152,9 +155,14 @@ oj_parse_xml_time(const char *str, int len) {
                     str++;
                     break;
                 }
-                nsec = nsec * 10 + (c - '0');
+                if (den > last_den_limit) {
+                    // bail to Time.parse if there are more fractional digits than a ULLONG rational can hold
+                    return rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(orig, len));
+                }
+                num = num * 10 + (c - '0');
+                den *= 10;
             }
-            args[5] = rb_float_new((double)n + ((double)nsec + 0.5) / 1000000000.0);
+            args[5] = rb_funcall(INT2NUM(n), oj_plus_id, 1, rb_rational_new(ULL2NUM(num), ULL2NUM(den)));
         } else {
             args[5] = rb_ll2inum(n);
         }
@@ -269,19 +277,10 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
                     // match the expected value.
                     parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
                 } else if (ni->has_exp) {
-                    int64_t          t = (int64_t)(ni->i + ni->exp);
-                    struct _timeInfo ti;
-                    VALUE            args[8];
-
-                    sec_as_time(t, &ti);
-                    args[0]     = LONG2NUM((long)(ti.year));
-                    args[1]     = LONG2NUM(ti.mon);
-                    args[2]     = LONG2NUM(ti.day);
-                    args[3]     = LONG2NUM(ti.hour);
-                    args[4]     = LONG2NUM(ti.min);
-                    args[5]     = rb_float_new((double)ti.sec + ((double)nsec + 0.5) / 1000000000.0);
-                    args[6]     = LONG2NUM(ni->exp);
-                    parent->val = rb_funcall2(rb_cTime, oj_new_id, 7, args);
+                    struct timespec ts;
+                    ts.tv_sec   = ni->i;
+                    ts.tv_nsec  = nsec;
+                    parent->val = rb_time_timespec_new(&ts, (int)ni->exp);
                 } else {
                     parent->val = rb_time_nano_new(ni->i, (long)nsec);
                 }
@@ -317,7 +316,7 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
                 return 1;
             }
-            e1 = *RARRAY_PTR(value);
+            e1 = *RARRAY_CONST_PTR(value);
             // check for anonymous Struct
             if (T_ARRAY == rb_type(e1)) {
                 VALUE          args[1024];
@@ -331,40 +330,44 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
             } else {
                 // If struct is not defined then we let this fail and raise an exception.
-                sc = oj_name2struct(pi, *RARRAY_PTR(value), rb_eArgError);
+                sc = oj_name2struct(pi, *RARRAY_CONST_PTR(value), rb_eArgError);
             }
-            // Create a properly initialized struct instance without calling the initialize method.
-            parent->val = rb_obj_alloc(sc);
-            // If the JSON array has more entries than the struct class allows, we record an error.
+            if (sc == rb_cRange) {
+                parent->val = rb_class_new_instance(len - 1, RARRAY_CONST_PTR(value) + 1, rb_cRange);
+            } else {
+                // Create a properly initialized struct instance without calling the initialize method.
+                parent->val = rb_obj_alloc(sc);
+                // If the JSON array has more entries than the struct class allows, we record an error.
 #ifdef RSTRUCT_LEN
 #if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
-            slen = (int)NUM2LONG(RSTRUCT_LEN(parent->val));
+                slen = (int)NUM2LONG(RSTRUCT_LEN(parent->val));
 #else   // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
-            slen = (int)RSTRUCT_LEN(parent->val);
+                slen = (int)RSTRUCT_LEN(parent->val);
 #endif  // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
 #else
-            slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
+                slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
 #endif
-            // MRI >= 1.9
-            if (len - 1 > slen) {
-                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
-            } else {
-                int i;
+                // MRI >= 1.9
+                if (len - 1 > slen) {
+                    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+                } else {
+                    int i;
 
-                for (i = 0; i < len - 1; i++) {
-                    rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+                    for (i = 0; i < len - 1; i++) {
+                        rb_struct_aset(parent->val, INT2FIX(i), RARRAY_CONST_PTR(value)[i + 1]);
+                    }
                 }
             }
             return 1;
         } else if (3 <= klen && '#' == key[1]) {
-            volatile VALUE *a;
+            volatile const VALUE *a;
 
             if (2 != len) {
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
                 return 1;
             }
             parent->val = rb_hash_new();
-            a           = RARRAY_PTR(value);
+            a           = RARRAY_CONST_PTR(value);
             rb_hash_aset(parent->val, *a, a[1]);
 
             return 1;
@@ -374,11 +377,17 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
 }
 
 void oj_set_obj_ivar(Val parent, Val kval, VALUE value) {
-    rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    if (kval->klen == 5 && strncmp("~mesg", kval->key, 5) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        parent->val = rb_funcall(parent->val, rb_intern("exception"), 1, value);
+    } else if (kval->klen == 3 && strncmp("~bt", kval->key, 3) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        rb_funcall(parent->val, rb_intern("set_backtrace"), 1, value);
+    } else {
+        rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    }
 }
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;
@@ -445,13 +454,11 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rval);
 }
 
 static void hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;
@@ -516,9 +523,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, rval);
 }
 
 static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
@@ -544,8 +549,8 @@ WHICH_TYPE:
             }
         } else {
             if (3 <= klen && '^' == *key && '#' == key[1] && T_ARRAY == rb_type(value)) {
-                long            len = RARRAY_LEN(value);
-                volatile VALUE *a   = RARRAY_PTR(value);
+                long                  len = RARRAY_LEN(value);
+                volatile const VALUE *a   = RARRAY_CONST_PTR(value);
 
                 if (2 != len) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
@@ -602,15 +607,11 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_value", pi, value);
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
     return Qnil;
 }
 
@@ -626,9 +627,7 @@ static void end_hash(ParseInfo pi) {
         oj_odd_free(oa);
         parent->odd_args = NULL;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
@@ -654,32 +653,24 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     }
     rval = str_to_value(pi, str, len, orig);
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rval);
 }
 
 static void array_append_num(ParseInfo pi, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     pi->stack.head->val = str_to_value(pi, str, len, orig);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, pi->stack.head->val);
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
     pi->stack.head->val = oj_num_as_value(ni);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_num", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_num", pi, pi->stack.head->val);
 }
 
 void oj_set_object_callbacks(ParseInfo pi) {

data/ext/oj/odd.c

@@ -5,6 +5,8 @@
 
 #include <string.h>
 
+#include "mem.h"
+
 static Odd odds = NULL;
 static ID  sec_id;
 static ID  sec_fraction_id;
@@ -68,7 +70,7 @@ void print_all_odds(const char *label) {
 }
 
 static Odd odd_create(void) {
-    Odd odd = ALLOC(struct _odd);
+    Odd odd = OJ_R_ALLOC(struct _odd);
 
     memset(odd, 0, sizeof(struct _odd));
     odd->next = odds;
@@ -172,7 +174,7 @@ Odd oj_get_oddc(const char *classname, size_t len) {
 }
 
 OddArgs oj_odd_alloc_args(Odd odd) {
-    OddArgs oa = ALLOC_N(struct _oddArgs, 1);
+    OddArgs oa = OJ_R_ALLOC_N(struct _oddArgs, 1);
     VALUE  *a;
     int     i;
 
@@ -184,7 +186,7 @@ OddArgs oj_odd_alloc_args(Odd odd) {
 }
 
 void oj_odd_free(OddArgs args) {
-    xfree(args);
+    OJ_R_FREE(args);
 }
 
 int oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
@@ -210,7 +212,7 @@ void oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt,
     odd       = odd_create();
     odd->clas = clas;
     rb_gc_register_mark_object(odd->clas);
-    if (NULL == (odd->classname = strdup(rb_class2name(clas)))) {
+    if (NULL == (odd->classname = OJ_STRDUP(rb_class2name(clas)))) {
         rb_raise(rb_eNoMemError, "for class name.");
     }
     odd->clen       = strlen(odd->classname);
@@ -224,13 +226,13 @@ void oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt,
         *fp = 0;
         switch (rb_type(*members)) {
         case T_STRING:
-            if (NULL == (*np = strdup(RSTRING_PTR(*members)))) {
+            if (NULL == (*np = OJ_STRDUP(RSTRING_PTR(*members)))) {
                 rb_raise(rb_eNoMemError, "for attribute name.");
             }
             break;
         case T_SYMBOL:
             // The symbol can move and invalidate the name so make a copy.
-            if (NULL == (*np = strdup(rb_id2name(SYM2ID(*members))))) {
+            if (NULL == (*np = OJ_STRDUP(rb_id2name(SYM2ID(*members))))) {
                 rb_raise(rb_eNoMemError, "for attribute name.");
             }
             break;

data/ext/oj/odd.h

@@ -14,7 +14,7 @@ typedef VALUE (*AttrGetFunc)(VALUE obj);
 
 typedef struct _odd {
     struct _odd *next;
-    const char * classname;
+    const char  *classname;
     size_t       clen;
     VALUE        clas;  // Ruby class or module
     VALUE        create_obj;
@@ -22,15 +22,15 @@ typedef struct _odd {
     int          attr_cnt;
     bool         is_module;
     bool         raw;
-    const char * attr_names[MAX_ODD_ARGS];  // NULL terminated attr names
+    const char  *attr_names[MAX_ODD_ARGS];  // NULL terminated attr names
     ID           attrs[MAX_ODD_ARGS];       // 0 terminated attr IDs
     AttrGetFunc  attrFuncs[MAX_ODD_ARGS];
-} * Odd;
+} *Odd;
 
 typedef struct _oddArgs {
     Odd   odd;
     VALUE args[MAX_ODD_ARGS];
-} * OddArgs;
+} *OddArgs;
 
 extern void    oj_odd_init(void);
 extern Odd     oj_get_odd(VALUE clas);