oj 3.16.11 → 3.17.6

data/ext/oj/dump.h

@@ -62,15 +62,27 @@ extern size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d,
 
 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);
     }
 }
 
+// Bytes that fill_indent(), or the dump_opts equivalent used when :indent is a
+// String, writes at this depth. nl_size is array_size or hash_size.
+inline static size_t indent_len(Out out, int depth, size_t nl_size) {
+    if (out->opts->dump_opts.use) {
+        return depth * out->opts->dump_opts.indent_size + nl_size;
+    }
+    return depth * out->indent + 1;
+}
+
 inline static void fill_indent(Out out, int cnt) {
     if (0 < out->indent) {
         cnt *= out->indent;
+        assure_size(out, cnt + 1);
         *out->cur++ = '\n';
         memset(out->cur, ' ', cnt);
         out->cur += cnt;

data/ext/oj/dump_compat.c

@@ -148,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);
                 }
@@ -162,6 +162,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
                     }
                 }
             } else {
+                assure_size(out, size);
                 fill_indent(out, d2);
             }
             oj_dump_compat_val(RARRAY_AREF(a, i), d2, out, true);
@@ -298,9 +299,10 @@ static ID message_id   = 0;
 static ID backtrace_id = 0;
 
 static void exception_alt(VALUE obj, int depth, Out out) {
-    int    d3      = depth + 2;
-    size_t size    = d3 * out->indent + 2;
-    size_t sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+    int            d3      = depth + 2;
+    size_t         size    = d3 * out->indent + 2;
+    size_t         sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+    volatile VALUE bt;
 
     if (0 == message_id) {
         message_id   = rb_intern("message");
@@ -331,7 +333,12 @@ static void exception_alt(VALUE obj, int depth, Out out) {
     if (0 < out->opts->dump_opts.after_size) {
         APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
     }
-    dump_array(rb_funcall(obj, backtrace_id, 0), depth, out, false);
+    bt = rb_funcall(obj, backtrace_id, 0);
+    if (T_ARRAY == rb_type(bt)) {
+        dump_array(bt, depth, out, false);
+    } else {
+        oj_dump_nil(Qnil, depth, out, false);
+    }
     fill_indent(out, depth);
     *out->cur++ = '}';
     *out->cur   = '\0';
@@ -605,6 +612,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);

data/ext/oj/dump_object.c

@@ -10,6 +10,24 @@ static const char hex_chars[17] = "0123456789abcdef";
 
 static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out);
 
+// An odd class is dumped as {"^O":class,...} and is rebuilt with a create
+// function when loaded so there is no place to put a "^i" circular id on it.
+// Registering it in the circular cache would consume an id that is never
+// written and any later occurrence would then be dumped as a "^r" that refers
+// to nothing. Instead dump odd classes in full each time they are encountered
+// just like Time, Rational, and Complex are.
+static void dump_circular_obj(VALUE obj, VALUE clas, int depth, Out out) {
+    if (NULL != oj_get_odd(clas)) {
+        dump_obj_attrs(obj, clas, 0, depth, out);
+    } else {
+        long id = oj_check_circular(obj, out);
+
+        if (0 <= id) {
+            dump_obj_attrs(obj, clas, id, depth, out);
+        }
+    }
+}
+
 static void dump_time(VALUE obj, Out out) {
     switch (out->opts->time_format) {
     case RubyTime:
@@ -47,11 +65,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
                 oj_dump_cstr(str, len, 0, 0, out);
             }
         } else {
-            long id = oj_check_circular(obj, out);
-
-            if (0 <= id) {
-                dump_obj_attrs(obj, clas, id, depth, out);
-            }
+            dump_circular_obj(obj, clas, depth, out);
         }
     }
 }
@@ -74,11 +88,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
             oj_dump_raw(str, len, out);
         }
     } else {
-        long id = oj_check_circular(obj, out);
-
-        if (0 <= id) {
-            dump_obj_attrs(obj, clas, id, depth, out);
-        }
+        dump_circular_obj(obj, clas, depth, out);
     }
 }
 
@@ -210,6 +220,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)) {

data/ext/oj/dump_strict.c

@@ -193,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 {
@@ -215,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);

data/ext/oj/extconf.rb

@@ -32,16 +32,20 @@ have_func('pthread_mutex_init')
 have_func('getrlimit', 'sys/resource.h')
 have_func('rb_enc_interned_str')
 have_func('rb_ext_ractor_safe', 'ruby.h')
+have_func('rb_hash_start', '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) {
@@ -103,12 +92,35 @@ inline static void next_non_white(ParseInfo pi) {
         case '\f':
         case '\n':
         case '\r': break;
-        case '/': skip_comment(pi); break;
+        case '/':
+            skip_comment(pi);
+            // A comment that is not terminated by a newline ends on the null
+            // terminator. Stop here so the loop does not step past it.
+            if ('\0' == *pi->s) {
+                return;
+            }
+            break;
         default: return;
         }
     }
 }
 
+inline static bool is_value_end(char c) {
+    switch (c) {
+    case '\0':
+    case ' ':
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r':
+    case '/':
+    case ',':
+    case ']':
+    case '}': return true;
+    default: return false;
+    }
+}
+
 inline static char *ulong_fill(char *s, size_t num) {
     char  buf[32];
     char *b = buf + sizeof(buf) - 1;
@@ -221,10 +233,11 @@ static void skip_comment(ParseInfo pi) {
             if ('*' == *pi->s && '/' == *(pi->s + 1)) {
                 pi->s++;
                 return;
-            } else if ('\0' == *pi->s) {
-                raise_error("comment not terminated", pi->str, pi->s);
             }
         }
+        // The loop only ends on the null terminator so the comment was never
+        // closed.
+        raise_error("comment not terminated", pi->str, pi->s);
     } else if ('/' == *pi->s) {
         for (; 1; pi->s++) {
             switch (*pi->s) {
@@ -246,6 +259,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;
@@ -265,7 +291,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);
@@ -448,27 +479,42 @@ static Leaf read_num(ParseInfo pi) {
     char *start = pi->s;
     int   type  = T_FIXNUM;
     Leaf  leaf;
+    int   dcnt = 0;
+    int   ecnt = 1;
 
-    if ('-' == *pi->s) {
+    // read_next() sends a leading '+' here as well, and Oj.load() takes one.
+    if ('-' == *pi->s || '+' == *pi->s) {
         pi->s++;
     }
     // digits
     for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+        dcnt++;
     }
     if ('.' == *pi->s) {
         type = T_FLOAT;
         pi->s++;
         for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+            dcnt++;
         }
     }
     if ('e' == *pi->s || 'E' == *pi->s) {
+        // An exponent makes it a float whether or not a '.' was seen. Without
+        // this leaf_fixnum_value() stops reading at the 'e' and the exponent is
+        // dropped.
+        type = T_FLOAT;
         pi->s++;
         if ('-' == *pi->s || '+' == *pi->s) {
             pi->s++;
         }
-        for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+        for (ecnt = 0; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+            ecnt++;
         }
     }
+    // A float is converted with rb_cstr_to_dbl(), which has to be given
+    // something it can convert.
+    if (T_FLOAT == type && (0 == dcnt || 0 == ecnt || !is_value_end(*pi->s))) {
+        raise_error("invalid number", pi->str, pi->s);
+    }
     leaf      = leaf_new(pi->doc, type);
     leaf->str = start;
 
@@ -655,7 +701,11 @@ static void doc_free(Doc doc) {
 static VALUE protect_open_proc(VALUE x) {
     ParseInfo pi = (ParseInfo)x;
 
-    pi->doc->data   = read_next(pi);  // parse
+    pi->doc->data = read_next(pi);  // parse
+    // read_obj() and read_array() terminate each value where it ends. The top
+    // level value has no closing delimiter to do that on, so a number leaf runs
+    // to the end of the document unless it is terminated here.
+    *pi->s          = '\0';
     *pi->doc->where = pi->doc->data;
     pi->doc->where  = pi->doc->where_path;
     if (rb_block_given_p()) {
@@ -703,21 +753,23 @@ static void mark_doc(void *ptr) {
 }
 #ifdef HAVE_RB_GC_MARK_MOVABLE
 static void compact_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                compact_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: leaf->value = rb_gc_location(leaf->value); break;
+                do {
+                    compact_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: leaf->value = rb_gc_location(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 
@@ -783,14 +835,11 @@ static VALUE parse_json(VALUE clas, char *json, bool given) {
     doc->self = self;
     result    = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
     if (given || 0 != ex) {
+        // The doc is detached from its wrapper so the GC will not free it.
+        // doc_free() releases both the doc and its json buffer (doc->json), so
+        // the caller must not free json separately.
         DATA_PTR(doc->self) = NULL;
-        // TBD is this needed?
-        /*
         doc_free(pi.doc);
-        if (0 != ex) {  // will jump so caller will not free
-            OJ_R_FREE(json);
-        }
-        */
     } else {
         result = doc->self;
     }
@@ -858,7 +907,7 @@ static bool key_match(const char *pat, const char *key, int plen) {
 static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
     Leaf leaf = *lp;
 
-    if (MAX_STACK <= lp - stack) {
+    if (MAX_STACK <= (lp + 1) - stack) {
         rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
     }
     if ('\0' != *path) {
@@ -939,6 +988,7 @@ static void each_leaf(Doc doc, VALUE self) {
 
             doc->where++;
             if (MAX_STACK <= doc->where - doc->where_path) {
+                doc->where--;
                 rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
             }
             do {
@@ -950,11 +1000,14 @@ static void each_leaf(Doc doc, VALUE self) {
         }
     } else {
         rb_yield(self);
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
 static int move_step(Doc doc, const char *path, int loc) {
-    if (MAX_STACK <= doc->where - doc->where_path) {
+    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);
     }
     if ('\0' == *path) {
@@ -962,8 +1015,9 @@ static int move_step(Doc doc, const char *path, int loc) {
     } else {
         Leaf leaf;
 
+        // A document with no root (empty or comment only JSON) has no leaf to
+        // step from so the path can not be located.
         if (0 == doc->where || 0 == (leaf = *doc->where)) {
-            printf("*** Internal error at %s\n", path);
             return loc;
         }
         if ('.' == *path && '.' == *(path + 1)) {
@@ -1043,19 +1097,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.");
+        }
     }
 }
 
@@ -1091,12 +1148,7 @@ static VALUE doc_open(VALUE clas, VALUE str) {
 
     memcpy(json, StringValuePtr(str), len);
     obj = parse_json(clas, json, given);
-    // TBD is this needed
-    /*
-    if (given) {
-        OJ_R_FREE(json);
-    }
-    */
+    // json is owned by the doc and freed by doc_free(); do not free it here.
     return obj;
 }
 
@@ -1128,7 +1180,9 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     int            given = rb_block_given_p();
 
     path = StringValuePtr(filename);
-    if (0 == (f = fopen(path, "r"))) {
+    // Open in binary mode. On Windows a text mode read translates CRLF into LF
+    // so fewer bytes are read than the file size reported by ftell().
+    if (0 == (f = fopen(path, "rb"))) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
     }
     fseek(f, 0, SEEK_END);
@@ -1146,12 +1200,7 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     fclose(f);
     json[len] = '\0';
     obj       = parse_json(clas, json, given);
-    // TBD is this needed
-    /*
-    if (given) {
-        OJ_R_FREE(json);
-    }
-    */
+    // json is owned by the doc and freed by doc_free(); do not free it here.
     return obj;
 }
 
@@ -1250,10 +1299,14 @@ static VALUE doc_path(VALUE self) {
  * #=> nil
  */
 static VALUE doc_local_key(VALUE self) {
-    Doc            doc  = self_doc(self);
-    Leaf           leaf = *doc->where;
-    volatile VALUE key  = Qnil;
+    Doc            doc = self_doc(self);
+    Leaf           leaf;
+    volatile VALUE key = Qnil;
 
+    if (NULL == doc->where || NULL == *doc->where) {
+        return Qnil;
+    }
+    leaf = *doc->where;
     if (T_HASH == leaf->parent_type) {
         key = rb_utf8_str_new_cstr(leaf->key);
     } else if (T_ARRAY == leaf->parent_type) {
@@ -1408,6 +1461,9 @@ static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
                 return Qnil;
             }
         }
+        if (NULL == doc->where || NULL == *doc->where) {
+            return Qnil;
+        }
         each_leaf(doc, self);
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
@@ -1491,12 +1547,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));
@@ -1540,7 +1603,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;
     }
@@ -97,6 +97,8 @@ static const rb_data_type_t oj_cache_type = {
 };
 
 void oj_hash_init(void) {
+    oj_hash_seed_init();
+
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
     rb_undef_alloc_func(cache_class);
 
@@ -151,7 +153,7 @@ ID oj_attr_intern(const char *key, size_t len) {
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
     const uint8_t *end     = key + len;
     const uint8_t *endless = key + (len & 0xFFFFFFFC);
-    uint64_t       h       = (uint64_t)len;
+    uint64_t       h       = (uint64_t)len ^ oj_hash_seed;
     uint64_t       k;
 
     while (key < endless) {
@@ -188,6 +190,9 @@ static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define
 
     if (rb_const_defined_at(mod, ci)) {
         clas = rb_const_get_at(mod, ci);
+        if (!RB_TYPE_P(clas, T_CLASS) && !RB_TYPE_P(clas, T_MODULE)) {
+            clas = Qundef;
+        }
     } else if (auto_define) {
         clas = rb_define_class_under(mod, classname, oj_bag_class);
     } else {

data/ext/oj/mimic_json.c

@@ -711,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
@@ -735,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