oj 3.16.6 → 3.17.3

data/ext/oj/dump.h

@@ -7,12 +7,17 @@
 #include <ruby.h>
 
 #include "oj.h"
+#include "simd.h"
 
 #define MAX_DEPTH 1000
 
 // Extra padding at end of buffer.
 #define BUFFER_EXTRA 64
 
+#ifdef HAVE_SIMD_NEON
+extern void initialize_neon(void);
+#endif /* HAVE_SIMD_NEON */
+
 extern void oj_dump_nil(VALUE obj, int depth, Out out, bool as_ok);
 extern void oj_dump_true(VALUE obj, int depth, Out out, bool as_ok);
 extern void oj_dump_false(VALUE obj, int depth, Out out, bool as_ok);
@@ -30,7 +35,7 @@ extern void oj_dump_xml_time(VALUE obj, Out out);
 extern void oj_dump_time(VALUE obj, Out out, int withZone);
 extern void oj_dump_obj_to_s(VALUE obj, Out out);
 
-extern const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, int *lenp);
+extern const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, size_t *lenp);
 
 // initialize an out buffer with the provided stack allocated memory
 extern void oj_out_init(Out out);
@@ -53,10 +58,12 @@ extern void oj_dump_raw_json(VALUE obj, int depth, Out out);
 extern VALUE oj_add_to_json(int argc, VALUE *argv, VALUE self);
 extern VALUE oj_remove_to_json(int argc, VALUE *argv, VALUE self);
 
-extern int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format);
+extern size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format);
 
 extern time_t oj_sec_from_time_hard_way(VALUE obj);
 
+extern bool oj_key_skip(VALUE key, const char *only, const char *except);
+
 inline static void assure_size(Out out, size_t len) {
     if (out->end - out->cur <= (long)len) {
         oj_grow_out(out, len);

data/ext/oj/dump_compat.c

@@ -103,7 +103,7 @@ static void dump_values_array(VALUE *values, int depth, Out out) {
 static void dump_to_json(VALUE obj, Out out) {
     volatile VALUE rs;
     const char    *s;
-    int            len;
+    size_t         len;
 
     TRACE(out->opts->trace, "to_json", obj, 0, TraceRubyIn);
     if (0 == rb_obj_method_arity(obj, oj_to_json_id)) {
@@ -115,7 +115,7 @@ static void dump_to_json(VALUE obj, Out out) {
 
     StringValue(rs);
     s   = RSTRING_PTR(rs);
-    len = (int)RSTRING_LEN(rs);
+    len = RSTRING_LEN(rs);
 
     assure_size(out, len + 1);
     APPEND_CHARS(out->cur, s, len);
@@ -124,7 +124,8 @@ static void dump_to_json(VALUE obj, Out out) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
     long   id = oj_check_circular(a, out);
 
@@ -136,7 +137,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         dump_to_json(a, out);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     assure_size(out, 2);
     if (0 == cnt) {
@@ -147,10 +148,10 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         } else {
             size = d2 * out->indent + 2;
         }
-        assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
             if (out->opts->dump_opts.use) {
+                assure_size(out, size);
                 if (0 < out->opts->dump_opts.array_size) {
                     APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }
@@ -552,7 +553,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char  *b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -590,7 +591,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
         strcpy(buf, RSTRING_PTR(rstr));
-        cnt = (int)RSTRING_LEN(rstr);
+        cnt = RSTRING_LEN(rstr);
     }
     assure_size(out, cnt);
     APPEND_CHARS(out->cur, buf, cnt);
@@ -604,6 +605,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     if (!out->opts->dump_opts.use) {
         assure_size(out, depth * out->indent + 1);
         fill_indent(out, depth);
@@ -800,7 +806,7 @@ static void dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     // rb_big2str can not so unless overridden by using add_to_json(Integer)
     // this must use to_s to pass the json gem unit tests.
     volatile VALUE rs;
-    int            cnt;
+    size_t         cnt;
     bool           dump_as_string = false;
 
     if (use_bignum_alt) {
@@ -809,7 +815,7 @@ static void dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
         rs = oj_safe_string_convert(obj);
     }
     rb_check_type(rs, T_STRING);
-    cnt = (int)RSTRING_LEN(rs);
+    cnt = RSTRING_LEN(rs);
 
     if (out->opts->int_range_min != 0 || out->opts->int_range_max != 0) {
         dump_as_string = true;  // Bignum cannot be inside of Fixnum range

data/ext/oj/dump_leaf.c

@@ -17,7 +17,7 @@ inline static void dump_chars(const char *s, size_t size, Out out) {
 static void dump_leaf_str(Leaf leaf, Out out) {
     switch (leaf->value_type) {
     case STR_VAL: oj_dump_cstr(leaf->str, strlen(leaf->str), 0, 0, out); break;
-    case RUBY_VAL: oj_dump_cstr(StringValueCStr(leaf->value), (int)RSTRING_LEN(leaf->value), 0, 0, out); break;
+    case RUBY_VAL: oj_dump_cstr(StringValueCStr(leaf->value), RSTRING_LEN(leaf->value), 0, 0, out); break;
     case COL_VAL:
     default: rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type); break;
     }

data/ext/oj/dump_object.c

@@ -33,7 +33,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
         if (oj_bigdecimal_class == clas) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
             const char    *str  = RSTRING_PTR(rstr);
-            int            len  = (int)RSTRING_LEN(rstr);
+            size_t         len  = RSTRING_LEN(rstr);
 
             if (No != out->opts->bigdec_as_num) {
                 oj_dump_raw(str, len, out);
@@ -62,7 +62,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
         const char    *str  = RSTRING_PTR(rstr);
-        int            len  = (int)RSTRING_LEN(rstr);
+        size_t         len  = RSTRING_LEN(rstr);
 
         if (0 == strcasecmp("Infinity", str)) {
             str = oj_nan_str(obj, out->opts->dump_opts.nan_dump, out->opts->mode, true, &len);
@@ -95,7 +95,8 @@ static void dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
     long   id = oj_check_circular(a, out);
 
@@ -106,7 +107,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
         dump_obj_attrs(a, clas, 0, depth, out);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     if (0 < id) {
         assure_size(out, d2 * out->indent + 16);
@@ -181,7 +182,7 @@ static void dump_str_class(VALUE obj, VALUE clas, int depth, Out out) {
         dump_obj_attrs(obj, clas, 0, depth, out);
     } else {
         const char *s   = RSTRING_PTR(obj);
-        size_t      len = (int)RSTRING_LEN(obj);
+        size_t      len = RSTRING_LEN(obj);
         char        s1  = s[1];
 
         oj_dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
@@ -195,7 +196,7 @@ static void dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 1, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), RSTRING_LEN(s), 1, 0, out);
 }
 
 static int hash_cb(VALUE key, VALUE value, VALUE ov) {
@@ -209,6 +210,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     assure_size(out, size);
     fill_indent(out, depth);
     switch (rb_type(key)) {
@@ -389,7 +395,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.");
         } else {
             const char *s    = RSTRING_PTR(v);
-            int         len  = (int)RSTRING_LEN(v);
+            size_t      len  = RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
 
@@ -489,7 +495,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
         *out->cur++ = ',';
         fill_indent(out, d2);
         APPEND_CHARS(out->cur, "\"self\":", 7);
-        oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
+        oj_dump_cstr(RSTRING_PTR(obj), RSTRING_LEN(obj), 0, 0, out);
         break;
     case T_ARRAY:
         assure_size(out, d2 * out->indent + 14);
@@ -564,11 +570,12 @@ static void dump_regexp(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     VALUE       clas       = rb_obj_class(obj);
     const char *class_name = rb_class2name(clas);
-    int         i;
-    int         d2   = depth + 1;
-    int         d3   = d2 + 1;
-    size_t      len  = strlen(class_name);
-    size_t      size = d2 * out->indent + d3 * out->indent + 10 + len;
+    size_t      i;
+    int         d2       = depth + 1;
+    int         d3       = d2 + 1;
+    size_t      len      = strlen(class_name);
+    size_t      size     = d2 * out->indent + d3 * out->indent + 10 + len;
+    char        circular = out->opts->circular;
 
     assure_size(out, size);
     *out->cur++ = '{';
@@ -577,14 +584,14 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     if ('#' == *class_name) {
         VALUE       ma = rb_struct_s_members(clas);
         const char *name;
-        int         cnt = (int)RARRAY_LEN(ma);
+        size_t      cnt = RARRAY_LEN(ma);
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
             volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
             name = RSTRING_PTR(s);
-            len  = (int)RSTRING_LEN(s);
+            len  = RSTRING_LEN(s);
             size = len + 3;
             assure_size(out, size);
             if (0 < i) {
@@ -607,14 +614,18 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     {
         VALUE v;
         int   cnt;
+
 #if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
         cnt = (int)NUM2LONG(RSTRUCT_LEN(obj));
 #else   // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
         cnt = (int)RSTRUCT_LEN(obj);
 #endif  // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
 
-        for (i = 0; i < cnt; i++) {
-            v = RSTRUCT_GET(obj, i);
+        if (0 == strcmp(class_name, "Range")) {
+            out->opts->circular = 'n';
+        }
+        for (i = 0; i < (size_t)cnt; i++) {
+            v = RSTRUCT_GET(obj, (int)i);
             if (dump_ignore(out->opts, v)) {
                 v = Qnil;
             }
@@ -630,6 +641,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         // class in interpreted Ruby so length() may not be defined.
         int slen = FIX2INT(rb_funcall2(obj, oj_length_id, 0, 0));
 
+        if (0 == strcmp(class_name, "Range")) {
+            out->opts->circular = 'n';
+        }
         for (i = 0; i < slen; i++) {
             assure_size(out, size);
             fill_indent(out, d3);
@@ -641,6 +655,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         }
     }
 #endif
+    out->opts->circular = circular;
     out->cur--;
     APPEND_CHARS(out->cur, "]}", 2);
     *out->cur = '\0';

data/ext/oj/dump_strict.c

@@ -30,7 +30,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char*  b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -92,7 +92,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         } else if (0 == out->opts->float_prec) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
-            cnt = (int)RSTRING_LEN(rstr);
+            cnt = RSTRING_LEN(rstr);
             if ((int)sizeof(buf) <= cnt) {
                 cnt = sizeof(buf) - 1;
             }
@@ -109,7 +109,8 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
     if (Yes == out->opts->circular) {
@@ -118,7 +119,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);
@@ -192,14 +193,19 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     if (!out->opts->dump_opts.use) {
         size = depth * out->indent + 1;
         assure_size(out, size);
         fill_indent(out, depth);
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         *out->cur++ = ':';
     } else {
@@ -214,10 +220,10 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
@@ -290,7 +296,7 @@ static void dump_data_strict(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
     } else {
         raise_strict(obj);
     }
@@ -302,7 +308,7 @@ static void dump_data_null(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
     } else {
         oj_dump_nil(Qnil, depth, out, false);
     }

data/ext/oj/extconf.rb

@@ -35,13 +35,16 @@ have_func('rb_ext_ractor_safe', 'ruby.h')
 
 dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
 
-if with_config('--with-sse42')
-  if try_cflags('-msse4.2')
-    $CPPFLAGS += ' -msse4.2'
-    dflags['OJ_USE_SSE4_2'] = 1
-  else
-    warn 'SSE 4.2 is not supported on this platform.'
-  end
+# SIMD optimizations use runtime CPU detection and function-level target attributes
+# We do NOT add global -msse4.2/-msse2 flags here because:
+# 1. It would cause illegal instruction errors on CPUs without SSE4.2
+# 2. The code uses __attribute__((target("sse4.2"))) for SSE4.2 functions
+# 3. Runtime detection in oj_get_simd_implementation() selects the right path
+#
+# We only add -msse2 if available, since SSE2 is baseline for all x86_64 CPUs
+# and needed for compiling the SSE2 fallback code on 32-bit x86
+if try_cflags('-msse2')
+  $CPPFLAGS += ' -msse2'
 end
 
 if enable_config('trace-log', false)

data/ext/oj/fast.c

@@ -80,21 +80,10 @@ static void  each_leaf(Doc doc, VALUE self);
 static int   move_step(Doc doc, const char *path, int loc);
 static Leaf  get_doc_leaf(Doc doc, const char *path);
 static Leaf  get_leaf(Leaf *stack, Leaf *lp, const char *path);
-static void  each_value(Doc doc, Leaf leaf);
+static void  each_value(Doc doc, Leaf leaf, VALUE self);
 
 VALUE oj_doc_class = Qundef;
 
-// This is only for CentOS 5.4 with Ruby 1.9.3-p0.
-#ifndef HAVE_STPCPY
-char *stpcpy(char *dest, const char *src) {
-    size_t cnt = strlen(src);
-
-    strcpy(dest, src);
-
-    return dest + cnt;
-}
-#endif
-
 inline static void next_non_white(ParseInfo pi) {
     for (; 1; pi->s++) {
         switch (*pi->s) {
@@ -193,8 +182,7 @@ static VALUE leaf_value(Doc doc, Leaf leaf) {
         case T_FIXNUM: leaf_fixnum_value(leaf); break;
         case T_FLOAT: leaf_float_value(leaf); break;
         case T_STRING:
-            leaf->value      = rb_str_new2(leaf->str);
-            leaf->value      = oj_encode(leaf->value);
+            leaf->value      = rb_utf8_str_new_cstr(leaf->str);
             leaf->value_type = RUBY_VAL;
             break;
         case T_ARRAY: return leaf_array_value(doc, leaf); break;
@@ -247,6 +235,19 @@ static void skip_comment(ParseInfo pi) {
 #define NUM_MAX (FIXNUM_MAX >> 8)
 #endif
 
+static void validate_integer_size(size_t limit, char *head, char *tail) {
+    size_t total       = (size_t)(tail - head);
+    bool   has_sign    = (head[0] == '-' || head[0] == '+');
+    size_t digit_count = total - (has_sign ? 1 : 0);
+
+    if (digit_count > limit) {
+        rb_raise(oj_parse_error_class,
+                 "integer exceeds :max_integer_digits (%lu > %lu)",
+                 (unsigned long)digit_count,
+                 (unsigned long)limit);
+    }
+}
+
 static void leaf_fixnum_value(Leaf leaf) {
     char   *s   = leaf->str;
     int64_t n   = 0;
@@ -266,7 +267,12 @@ static void leaf_fixnum_value(Leaf leaf) {
         }
     }
     if (big) {
-        char c = *s;
+        size_t limit = oj_default_options.max_integer_digits;
+        char   c     = *s;
+
+        if (0 < limit) {
+            validate_integer_size(limit, leaf->str, s);
+        }
 
         *s          = '\0';
         leaf->value = rb_cstr_to_inum(leaf->str, 10, 0);
@@ -309,8 +315,7 @@ static VALUE leaf_hash_value(Doc doc, Leaf leaf) {
         volatile VALUE key;
 
         do {
-            key = rb_str_new2(e->key);
-            key = oj_encode(key);
+            key = rb_utf8_str_new_cstr(e->key);
             rb_hash_aset(h, key, leaf_value(doc, e));
             e = e->next;
         } while (e != first);
@@ -952,6 +957,9 @@ static void each_leaf(Doc doc, VALUE self) {
         }
     } else {
         rb_yield(self);
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1045,19 +1053,22 @@ static int move_step(Doc doc, const char *path, int loc) {
     return loc;
 }
 
-static void each_value(Doc doc, Leaf leaf) {
+static void each_value(Doc doc, Leaf leaf, VALUE self) {
     if (COL_VAL == leaf->value_type) {
         if (0 != leaf->elements) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
 
             do {
-                each_value(doc, e);
+                each_value(doc, e, self);
                 e = e->next;
             } while (e != first);
         }
     } else {
         rb_yield(leaf_value(doc, leaf));
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1088,7 +1099,7 @@ static VALUE doc_open(VALUE clas, VALUE str) {
     int            given = rb_block_given_p();
 
     Check_Type(str, T_STRING);
-    len  = (int)RSTRING_LEN(str) + 1;
+    len  = RSTRING_LEN(str) + 1;
     json = OJ_R_ALLOC_N(char, len);
 
     memcpy(json, StringValuePtr(str), len);
@@ -1257,8 +1268,7 @@ static VALUE doc_local_key(VALUE self) {
     volatile VALUE key  = Qnil;
 
     if (T_HASH == leaf->parent_type) {
-        key = rb_str_new2(leaf->key);
-        key = oj_encode(key);
+        key = rb_utf8_str_new_cstr(leaf->key);
     } else if (T_ARRAY == leaf->parent_type) {
         key = LONG2NUM(leaf->index);
     }
@@ -1494,12 +1504,19 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
             Leaf first = (*doc->where)->elements->next;
             Leaf e     = first;
 
+            if (MAX_STACK <= (doc->where + 1) - doc->where_path) {
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
+            }
             doc->where++;
             do {
                 *doc->where = e;
                 rb_yield(self);
+                if (NULL == DATA_PTR(self)) {
+                    rb_raise(rb_eIOError, "Document closed.");
+                }
                 e = e->next;
             } while (e != first);
+            doc->where--;
         }
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
@@ -1543,7 +1560,7 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
-            each_value(doc, leaf);
+            each_value(doc, leaf, self);
         }
     }
     return Qnil;

data/ext/oj/intern.c

@@ -69,7 +69,7 @@ static VALUE form_attr(const char *str, size_t len) {
             memcpy(b + 1, str, len);
             b[len + 1] = '\0';
         }
-        id = rb_intern3(buf, len + 1, oj_utf8_encoding);
+        id = rb_intern3(b, len + 1, oj_utf8_encoding);
         OJ_R_FREE(b);
         return id;
     }

data/ext/oj/mimic_json.c

@@ -246,8 +246,7 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
     if (0 == out.buf) {
         rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
+    rstr = rb_utf8_str_new_cstr(out.buf);
     if (2 <= argc && Qnil != argv[1] && rb_respond_to(argv[1], oj_write_id)) {
         VALUE io = argv[1];
         VALUE args[1];
@@ -396,8 +395,7 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     if (0 == out.buf) {
         rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
+    rstr = rb_utf8_str_new_cstr(out.buf);
 
     oj_out_free(&out);
 
@@ -713,6 +711,7 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        0,              // cache_str
                                                        0,              // int_range_min
                                                        0,              // int_range_max
+                                                       0,              // max_integer_digits
                                                        oj_json_class,  // create_id
                                                        10,             // create_id_len
                                                        3,              // sec_prec
@@ -737,6 +736,8 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                            false,     // omit_nil
                                                            false,     // omit_null_byte
                                                            100,       // max_depth
+                                                           NULL,      // only
+                                                           NULL,      // except
                                                        },
                                                        {
                                                            // str_rx
@@ -768,8 +769,7 @@ static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     if (NULL == out.buf) {
         rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
+    rstr = rb_utf8_str_new_cstr(out.buf);
 
     oj_out_free(&out);
 
@@ -837,11 +837,15 @@ void oj_mimic_json_methods(VALUE json) {
     } else {
         json_error = rb_define_class_under(json, "JSONError", rb_eStandardError);
     }
+
+    rb_global_variable(&oj_json_parser_error_class);
     if (rb_const_defined_at(json, rb_intern("ParserError"))) {
         oj_json_parser_error_class = rb_const_get(json, rb_intern("ParserError"));
     } else {
         oj_json_parser_error_class = rb_define_class_under(json, "ParserError", json_error);
     }
+
+    rb_global_variable(&oj_json_generator_error_class);
     if (rb_const_defined_at(json, rb_intern("GeneratorError"))) {
         oj_json_generator_error_class = rb_const_get(json, rb_intern("GeneratorError"));
     } else {
@@ -867,8 +871,8 @@ void oj_mimic_json_methods(VALUE json) {
         rb_require("oj/state");
     }
     // Pull in the JSON::State mimic file.
+    rb_global_variable(&state_class);
     state_class = rb_const_get_at(generator, rb_intern("State"));
-    rb_gc_register_mark_object(state_class);
 }
 
 /* Document-module: JSON