oj 3.13.7 → 3.13.11

data/ext/oj/intern.c

@@ -186,6 +186,7 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     char *      end = class_name + sizeof(class_name) - 1;
     char *      s;
     const char *n = name;
+    size_t	nlen = len;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
@@ -208,7 +209,12 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+	if (sizeof(class_name) <= nlen) {
+	    nlen = sizeof(class_name) - 1;
+	}
+	strncpy(class_name, name, nlen);
+	class_name[nlen] = '\0';
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class '%s' is not defined", class_name);
         if (Qnil != error_class) {
             pi->err_class = error_class;
         }

data/ext/oj/mimic_json.c

@@ -6,8 +6,6 @@
 #include "oj.h"
 #include "parse.h"
 
-static VALUE symbolize_names_sym = Qundef;
-
 extern const char oj_json_class[];
 
 VALUE oj_array_nl_sym;
@@ -274,7 +272,7 @@ static int mimic_walk(VALUE key, VALUE obj, VALUE proc) {
         size_t i;
 
         for (i = 0; i < cnt; i++) {
-            mimic_walk(Qnil, rb_ary_entry(obj, i), proc);
+            mimic_walk(Qnil, RARRAY_AREF(obj, i), proc);
         }
         break;
     }
@@ -501,6 +499,52 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     return mimic_generate_core(2, rargs, &copts);
 }
 
+static int parse_options_cb(VALUE k, VALUE v, VALUE info) {
+    struct _parseInfo *pi = (struct _parseInfo *)info;
+
+    if (oj_symbolize_names_sym == k) {
+        pi->options.sym_key = (Qtrue == v) ? Yes : No;
+    } else if (oj_quirks_mode_sym == k) {
+        pi->options.quirks_mode = (Qtrue == v) ? Yes : No;
+    } else if (oj_create_additions_sym == k) {
+        pi->options.create_ok = (Qtrue == v) ? Yes : No;
+    } else if (oj_allow_nan_sym == k) {
+        pi->options.allow_nan = (Qtrue == v) ? Yes : No;
+    } else if (oj_hash_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_object_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_array_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.array_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.array_class = v;
+        }
+    } else if (oj_decimal_class_sym == k) {
+        pi->options.compat_bigdec = (oj_bigdecimal_class == v);
+    } else if (oj_max_nesting_sym == k) {
+        if (Qtrue == v) {
+            pi->max_depth = 100;
+        } else if (Qfalse == v || Qnil == v) {
+            pi->max_depth = 0;
+        } else if (T_FIXNUM == rb_type(v)) {
+            pi->max_depth = NUM2INT(v);
+        }
+    }
+    return ST_CONTINUE;
+}
+
 static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
     struct _parseInfo pi;
     VALUE             ropts;
@@ -526,63 +570,11 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
     pi.max_depth             = 100;
 
     if (Qnil != ropts) {
-        VALUE v;
-
         if (T_HASH != rb_type(ropts)) {
             rb_raise(rb_eArgError, "options must be a hash.");
         }
-        if (Qundef == symbolize_names_sym) {
-            symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));
-            rb_gc_register_address(&symbolize_names_sym);
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, symbolize_names_sym))) {
-            pi.options.sym_key = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_quirks_mode_sym))) {
-            pi.options.quirks_mode = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_create_additions_sym))) {
-            pi.options.create_ok = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_allow_nan_sym))) {
-            pi.options.allow_nan = (Qtrue == v) ? Yes : No;
-        }
 
-        if (oj_hash_has_key(ropts, oj_hash_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_hash_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_object_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_object_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_array_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_array_class_sym))) {
-                pi.options.array_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.array_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_decimal_class_sym)) {
-            pi.options.compat_bigdec = (oj_bigdecimal_class == rb_hash_lookup(ropts, oj_decimal_class_sym));
-        }
-        v = rb_hash_lookup(ropts, oj_max_nesting_sym);
-        if (Qtrue == v) {
-            pi.max_depth = 100;
-        } else if (Qfalse == v || Qnil == v) {
-            pi.max_depth = 0;
-        } else if (T_FIXNUM == rb_type(v)) {
-            pi.max_depth = NUM2INT(v);
-        }
+        rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
         oj_parse_opt_match_string(&pi.options.str_rx, ropts);
         if (Yes == pi.options.create_ok && Yes == pi.options.sym_key) {
             rb_raise(rb_eArgError, ":symbolize_names and :create_additions can not both be true.");
@@ -852,9 +844,6 @@ void oj_mimic_json_methods(VALUE json) {
     // Pull in the JSON::State mimic file.
     state_class = rb_const_get_at(generator, rb_intern("State"));
     rb_gc_register_mark_object(state_class);
-
-    symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));
-    rb_gc_register_address(&symbolize_names_sym);
 }
 
 /* Document-module: JSON

data/ext/oj/object.c

@@ -35,7 +35,7 @@ static VALUE calc_hash_key(ParseInfo pi, Val kval, char k1) {
         return ID2SYM(rb_intern3(kval->key + 1, kval->klen - 1, oj_utf8_encoding));
     }
     if (Yes == pi->options.sym_key) {
-	return ID2SYM(rb_intern3(kval->key, kval->klen, oj_utf8_encoding));
+        return ID2SYM(rb_intern3(kval->key, kval->klen, oj_utf8_encoding));
     }
 #if HAVE_RB_ENC_INTERNED_STR
     rkey = rb_enc_interned_str(kval->key, kval->klen, oj_utf8_encoding);
@@ -60,21 +60,16 @@ static VALUE str_to_value(ParseInfo pi, const char *str, size_t len, const char
         }
         rstr = oj_circ_array_get(pi->circ_array, i);
     } else {
-	rstr = rb_utf8_str_new(str, len);
+        rstr = rb_utf8_str_new(str, len);
     }
     return rstr;
 }
 
-#if (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
-static VALUE oj_parse_xml_time(const char *str, int len) {
-    return rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(str, len));
-}
-#else
 // 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;
@@ -88,9 +83,9 @@ 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];
+    VALUE args[8];
     const char *end = str + len;
-    int         n;
+    int n;
 
     // year
     if (0 > (n = parse_num(str, end, 4))) {
@@ -201,7 +196,6 @@ oj_parse_xml_time(const char *str, int len) {
     }
     return rb_funcall2(rb_cTime, oj_new_id, 7, args);
 }
-#endif
 
 static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t len) {
     const char *key  = kval->key;
@@ -226,13 +220,10 @@ static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t
             }
             parent->val      = odd->clas;
             parent->odd_args = oj_odd_alloc_args(odd);
-        } break;
-        case 'm':
-            parent->val = ID2SYM(rb_intern3(str + 1, len - 1, oj_utf8_encoding));
-            break;
-        case 's':
-	    parent->val = rb_utf8_str_new(str, len);
             break;
+        }
+        case 'm': parent->val = ID2SYM(rb_intern3(str + 1, len - 1, oj_utf8_encoding)); break;
+        case 's': parent->val = rb_utf8_str_new(str, len); break;
         case 'c':  // class
         {
             VALUE clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define, rb_eArgError);
@@ -242,7 +233,8 @@ static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t
             } else {
                 parent->val = clas;
             }
-        } break;
+            break;
+        }
         case 't':  // time
             parent->val = oj_parse_xml_time(str, (int)len);
             break;
@@ -282,22 +274,21 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
                     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);
+                    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);
                 } else {
                     parent->val = rb_time_nano_new(ni->i, (long)nsec);
                 }
             }
             break;
-        case 'i':  // circular index
-            if (!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp &&
-                0 != pi->circ_array) {  // fixnum
+        case 'i':                                                                                    // circular index
+            if (!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) {  // fixnum
                 if (Qnil == parent->val) {
                     parent->val = rb_hash_new();
                 }
@@ -334,7 +325,7 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 int            i, cnt = (int)RARRAY_LEN(e1);
 
                 for (i = 0; i < cnt; i++) {
-                    rstr    = rb_ary_entry(e1, i);
+                    rstr    = RARRAY_AREF(e1, i);
                     args[i] = rb_funcall(rstr, oj_to_sym_id, 0);
                 }
                 sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
@@ -402,9 +393,7 @@ WHICH_TYPE:
         }
         break;
     case T_HASH:
-        rb_hash_aset(parent->val,
-                     calc_hash_key(pi, kval, parent->k1),
-                     str_to_value(pi, str, len, orig));
+        rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), str_to_value(pi, str, len, orig));
         break;
     case T_STRING:
         rval = str_to_value(pi, str, len, orig);
@@ -481,8 +470,8 @@ WHICH_TYPE:
         rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), rval);
         break;
     case T_OBJECT:
-        if (2 == klen && '^' == *key && 'i' == key[1] && !ni->infinity && !ni->neg &&
-            1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) {  // fixnum
+        if (2 == klen && '^' == *key && 'i' == key[1] && !ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp &&
+            0 != pi->circ_array) {  // fixnum
             oj_circ_array_set(pi->circ_array, parent->val, ni->i);
         } else {
             rval = oj_num_as_value(ni);
@@ -559,11 +548,7 @@ WHICH_TYPE:
                 volatile VALUE *a   = RARRAY_PTR(value);
 
                 if (2 != len) {
-                    oj_set_error_at(pi,
-                                    oj_parse_error_class,
-                                    __FILE__,
-                                    __LINE__,
-                                    "invalid hash pair");
+                    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
                     return;
                 }
                 rb_hash_aset(parent->val, *a, a[1]);
@@ -637,10 +622,7 @@ static void end_hash(ParseInfo pi) {
     } else if (NULL != parent->odd_args) {
         OddArgs oa = parent->odd_args;
 
-        parent->val = rb_funcall2(oa->odd->create_obj,
-                                  oa->odd->create_op,
-                                  oa->odd->attr_cnt,
-                                  oa->args);
+        parent->val = rb_funcall2(oa->odd->create_obj, oa->odd->create_op, oa->odd->attr_cnt, oa->args);
         oj_odd_free(oa);
         parent->odd_args = NULL;
     }
@@ -653,8 +635,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rval = Qnil;
 
     // orig lets us know whether the string was ^r1 or \u005er1
-    if (3 <= len && 0 != pi->circ_array && '^' == orig[0] &&
-        0 == rb_array_len(stack_peek(&pi->stack)->val)) {
+    if (3 <= len && 0 != pi->circ_array && '^' == orig[0] && 0 == rb_array_len(stack_peek(&pi->stack)->val)) {
         if ('i' == str[1]) {
             long i = read_long(str + 2, len - 2);