oj 3.17.7 → 3.17.8

data/ext/oj/dump.c

@@ -587,6 +587,9 @@ long oj_check_circular(VALUE obj, Out out) {
     slot_t *slot;
 
     if (Yes == out->opts->circular) {
+        if (NULL == out->circ_cache) {
+            oj_cache8_new(&out->circ_cache);
+        }
         if (0 == (id = oj_cache8_get(out->circ_cache, obj, &slot))) {
             out->circ_cnt++;
             id    = out->circ_cnt;
@@ -831,28 +834,61 @@ void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int arg
     *out->cur = '\0';
     if (Yes == copts->circular) {
         oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
     }
 }
 
-void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
-    struct _out out;
-    size_t      size;
-    FILE       *f;
-    int         ok;
+struct dump_str_arg {
+    VALUE   obj;
+    Options copts;
+    Out     out;
+    int     argc;
+    VALUE  *argv;
+};
 
-    oj_out_init(&out);
+static VALUE dump_str_body(VALUE a) {
+    struct dump_str_arg *arg = (struct dump_str_arg *)a;
 
-    out.omit_nil = copts->dump_opts.omit_nil;
-    oj_dump_obj_to_json(obj, copts, &out);
-    size = out.cur - out.buf;
-    if (0 == (f = fopen(path, "w"))) {
-        oj_out_free(&out);
-        rb_raise(rb_eIOError, "%s", strerror(errno));
+    oj_dump_obj_to_json_using_params(arg->obj, arg->copts, arg->out, arg->argc, arg->argv);
+    if (0 == arg->out->buf) {
+        rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    ok = (size == fwrite(out.buf, 1, size, f));
+    return rb_utf8_str_new_cstr(arg->out->buf);
+}
+
+static VALUE out_free_ensure(VALUE out) {
+    oj_out_free((Out)out);
+
+    return Qnil;
+}
 
-    oj_out_free(&out);
+VALUE oj_dump_obj_to_str(VALUE obj, Options copts, Out out, int argc, VALUE *argv) {
+    struct dump_str_arg arg = {obj, copts, out, argc, argv};
 
+    return rb_ensure(dump_str_body, (VALUE)&arg, out_free_ensure, (VALUE)out);
+}
+
+struct write_arg {
+    VALUE       obj;
+    VALUE       stream;
+    const char *path;
+    Options     copts;
+    Out         out;
+};
+
+static VALUE write_file_body(VALUE a) {
+    struct write_arg *arg = (struct write_arg *)a;
+    Out               out = arg->out;
+    size_t            size;
+    FILE             *f;
+    int               ok;
+
+    oj_dump_obj_to_json(arg->obj, arg->copts, out);
+    size = out->cur - out->buf;
+    if (0 == (f = fopen(arg->path, "w"))) {
+        rb_raise(rb_eIOError, "%s", strerror(errno));
+    }
+    ok = (size == fwrite(out->buf, 1, size, f));
     if (!ok) {
         int err = ferror(f);
         fclose(f);
@@ -860,6 +896,18 @@ void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
         rb_raise(rb_eIOError, "Write failed. [%d:%s]", err, strerror(err));
     }
     fclose(f);
+
+    return Qnil;
+}
+
+void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
+    struct _out      out;
+    struct write_arg arg = {obj, Qnil, path, copts, &out};
+
+    oj_out_init(&out);
+
+    out.omit_nil = copts->dump_opts.omit_nil;
+    rb_ensure(write_file_body, (VALUE)&arg, out_free_ensure, (VALUE)&out);
 }
 
 #if !IS_WINDOWS
@@ -879,22 +927,21 @@ static void write_ready(int fd) {
 }
 #endif
 
-void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
-    struct _out out;
-    ssize_t     size;
-    VALUE       clas = rb_obj_class(stream);
+static VALUE write_stream_body(VALUE a) {
+    struct write_arg *arg    = (struct write_arg *)a;
+    Out               out    = arg->out;
+    VALUE             stream = arg->stream;
+    ssize_t           size;
+    VALUE             clas = rb_obj_class(stream);
 #if !IS_WINDOWS
     int   fd;
     VALUE s;
 #endif
 
-    oj_out_init(&out);
-
-    out.omit_nil = copts->dump_opts.omit_nil;
-    oj_dump_obj_to_json(obj, copts, &out);
-    size = out.cur - out.buf;
+    oj_dump_obj_to_json(arg->obj, arg->copts, out);
+    size = out->cur - out->buf;
     if (oj_stringio_class == clas) {
-        rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
+        rb_funcall(stream, oj_write_id, 1, rb_str_new(out->buf, size));
 #if !IS_WINDOWS
     } else if (rb_respond_to(stream, oj_fileno_id) && Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
                0 != (fd = FIX2INT(s))) {
@@ -902,7 +949,7 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
         ssize_t total = 0;
 
         while (true) {
-            if (0 > (cnt = write(fd, out.buf + total, size - total))) {
+            if (0 > (cnt = write(fd, out->buf + total, size - total))) {
                 if (EAGAIN != errno) {
                     rb_raise(rb_eIOError, "write failed. %d %s.", errno, strerror(errno));
                     break;
@@ -917,22 +964,32 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
         }
 #endif
     } else if (rb_respond_to(stream, oj_write_id)) {
-        rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
+        rb_funcall(stream, oj_write_id, 1, rb_str_new(out->buf, size));
     } else {
-        oj_out_free(&out);
         rb_raise(rb_eArgError, "to_stream() expected an IO Object.");
     }
-    oj_out_free(&out);
+    return Qnil;
+}
+
+void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
+    struct _out      out;
+    struct write_arg arg = {obj, stream, NULL, copts, &out};
+
+    oj_out_init(&out);
+
+    out.omit_nil = copts->dump_opts.omit_nil;
+    rb_ensure(write_stream_body, (VALUE)&arg, out_free_ensure, (VALUE)&out);
 }
 
 void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
     int idx = RB_ENCODING_GET(obj);
 
-    if (oj_utf8_encoding_index != idx) {
+    if (oj_utf8_encoding_index != idx && !rb_enc_str_asciionly_p(obj)) {
         rb_encoding *enc = rb_enc_from_index(idx);
         obj              = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
     oj_dump_cstr(RSTRING_PTR(obj), RSTRING_LEN(obj), 0, 0, out);
+    RB_GC_GUARD(obj);
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
@@ -968,6 +1025,7 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
         if (0 < len) {
             len--;
         }
+        assure_size(out, len + 10);
         oj_dump_raw(sw->out.buf, len, out);
     } else {
         volatile VALUE jv;
@@ -975,6 +1033,7 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
         TRACE(out->opts->trace, "raw_json", obj, depth + 1, TraceRubyIn);
         jv = rb_funcall(obj, oj_raw_json_id, 2, RB_INT2NUM(depth), RB_INT2NUM(out->indent));
         TRACE(out->opts->trace, "raw_json", obj, depth + 1, TraceRubyOut);
+        StringValue(jv);
         oj_dump_raw(RSTRING_PTR(jv), (size_t)RSTRING_LEN(jv), out);
     }
 }
@@ -1461,12 +1520,17 @@ void oj_out_init(Out out) {
     out->end            = out->buf + sizeof(out->stack_buffer) - BUFFER_EXTRA;
     out->allocated      = false;
     out->key_filter_off = false;
+    out->circ_cache     = NULL;
 }
 
 void oj_out_free(Out out) {
     if (out->allocated) {
         OJ_R_FREE(out->buf);  // TBD
     }
+    if (NULL != out->circ_cache) {
+        oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
+    }
 }
 
 void oj_grow_out(Out out, size_t len) {

data/ext/oj/dump_compat.c

@@ -321,7 +321,7 @@ 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);
     }
-    oj_dump_str(rb_funcall(obj, message_id, 0), 0, out, false);
+    oj_dump_compat_val(rb_funcall(obj, message_id, 0), depth + 1, out, true);
     assure_size(out, size + sep_len + 6);
     *out->cur++ = ',';
     fill_indent(out, d3);
@@ -470,9 +470,6 @@ oj_add_to_json(int argc, VALUE *argv, VALUE self) {
 
     if (0 == argc) {
         for (a = oj_compat_codes; NULL != a->name; a++) {
-            if (Qnil == a->clas || Qundef == a->clas) {
-                a->clas = rb_const_get_at(rb_cObject, rb_intern(a->name));
-            }
             a->active = true;
         }
         use_struct_alt    = true;
@@ -503,10 +500,7 @@ oj_add_to_json(int argc, VALUE *argv, VALUE self) {
                 continue;
             }
             for (a = oj_compat_codes; NULL != a->name; a++) {
-                if (Qnil == a->clas || Qundef == a->clas) {
-                    a->clas = rb_const_get_at(rb_cObject, rb_intern(a->name));
-                }
-                if (*argv == a->clas) {
+                if (*argv == oj_code_class(a)) {
                     a->active = true;
                     break;
                 }
@@ -563,12 +557,15 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     size_t cnt = 0;
 
     if (0.0 == d) {
-        b    = buf;
+        b = buf;
+        if (signbit(d)) {
+            *b++ = '-';
+        }
         *b++ = '0';
         *b++ = '.';
         *b++ = '0';
-        *b++ = '\0';
-        cnt  = 3;
+        *b   = '\0';
+        cnt  = b - buf;
     } else if (OJ_INFINITY == d) {
         if (WordNan == out->opts->dump_opts.nan_dump) {
             strcpy(buf, "Infinity");

data/ext/oj/dump_object.c

@@ -143,6 +143,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
         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);
                 }
@@ -160,7 +161,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
                 *out->cur++ = ',';
             }
         }
-        size = depth * out->indent + 1;
+        size = indent_len(out, depth, out->opts->dump_opts.array_size) + 1;
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             // printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size,
@@ -350,7 +351,7 @@ static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     } else if (Yes == out->opts->ignore_under && '@' == *attr && '_' == attr[1]) {
         return ST_CONTINUE;
     }
-    if (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr)) {
+    if ('@' != *attr && (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr) || 0 == strcmp("bt_locations", attr))) {
         return ST_CONTINUE;
     }
     assure_size(out, size);
@@ -611,6 +612,10 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             APPEND_CHARS(out->cur, name, len);
             *out->cur++ = '"';
         }
+        if (2 == cnt && rb_obj_is_kind_of(obj, rb_cRange)) {
+            assure_size(out, 8);
+            APPEND_CHARS(out->cur, ",\"excl\"", 7);
+        }
         *out->cur++ = ']';
     } else {
         fill_indent(out, d3);
@@ -644,6 +649,17 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             oj_dump_obj_val(v, d3, out);
             *out->cur++ = ',';
         }
+        if (2 == cnt && rb_obj_is_kind_of(obj, rb_cRange)) {
+            VALUE beg;
+            VALUE end;
+            int   excl;
+
+            rb_range_values(obj, &beg, &end, &excl);
+            assure_size(out, size);
+            fill_indent(out, d3);
+            oj_dump_obj_val(excl ? Qtrue : Qfalse, d3, out);
+            *out->cur++ = ',';
+        }
     }
 #else
     {

data/ext/oj/dump_strict.c

@@ -135,6 +135,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         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);
                 }
@@ -156,7 +157,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
                 *out->cur++ = ',';
             }
         }
-        size = depth * out->indent + 1;
+        size = indent_len(out, depth, out->opts->dump_opts.array_size) + 1;
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             // printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size,

data/ext/oj/extconf.rb

@@ -33,7 +33,6 @@ have_func('getrlimit', 'sys/resource.h')
 have_func('rb_enc_interned_str')
 have_func('rb_hash_new_capa', 'ruby.h')
 have_func('rb_ext_ractor_safe', 'ruby.h')
-have_func('rb_hash_start', 'ruby.h')
 
 dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
 

data/ext/oj/fast.c

@@ -838,8 +838,10 @@ static VALUE parse_json(VALUE clas, char *json, bool given) {
         // 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;
-        doc_free(pi.doc);
+        if (NULL != DATA_PTR(self)) {
+            DATA_PTR(self) = NULL;
+            doc_free(doc);
+        }
     } else {
         result = doc->self;
     }
@@ -1034,8 +1036,8 @@ static int move_step(Doc doc, const char *path, int loc) {
             doc->where--;
             loc = move_step(doc, path, loc + 1);
             if (0 != loc) {
-                *doc->where = init;
                 doc->where++;
+                *doc->where = init;
             }
         } else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
             Leaf first = leaf->elements->next;
@@ -1179,19 +1181,24 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     volatile VALUE obj;
     int            given = rb_block_given_p();
 
-    path = StringValuePtr(filename);
+    path = StringValueCStr(filename);
     // 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);
-    len  = ftell(f);
+    len = ftell(f);
+    if ((size_t)-1 == len) {
+        fclose(f);
+        rb_raise(rb_const_get_at(Oj, rb_intern("LoadError")), "Failed to get the size of %s.", path);
+    }
     json = OJ_R_ALLOC_N(char, len + 1);
 
     fseek(f, 0, SEEK_SET);
     if (len != fread(json, 1, len, f)) {
         fclose(f);
+        OJ_R_FREE(json);
         rb_raise(rb_const_get_at(Oj, rb_intern("LoadError")),
                  "Failed to read %lu bytes from %s.",
                  (unsigned long)len,
@@ -1344,7 +1351,7 @@ static VALUE doc_home(VALUE self) {
  *   Oj::Doc.open('[1,2]') { |doc| doc.type('/1') }  #=> Fixnum
  */
 static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
-    Doc         doc = self_doc(self);
+    Doc         doc;
     Leaf        leaf;
     const char *path = 0;
     VALUE       type = Qnil;
@@ -1352,6 +1359,7 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     if (1 <= argc) {
         path = StringValuePtr(*argv);
     }
+    doc = self_doc(self);
     if (0 != (leaf = get_doc_leaf(doc, path))) {
         switch (leaf->rtype) {
         case T_NIL: type = rb_cNilClass; break;
@@ -1387,13 +1395,13 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     volatile VALUE val  = Qnil;
     const char    *path = 0;
 
-    doc = self_doc(self);
     if (1 <= argc) {
         path = StringValuePtr(*argv);
         if (2 == argc) {
             val = argv[1];
         }
     }
+    doc = self_doc(self);
     if (0 != (leaf = get_doc_leaf(doc, path))) {
         val = leaf_value(doc, leaf);
     }
@@ -1409,11 +1417,11 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
  *   Oj::Doc.open('[1,2]') { |doc| doc.exists?('/3') }  #=> false
  */
 static VALUE doc_exists(VALUE self, VALUE str) {
-    Doc  doc;
-    Leaf leaf;
+    const char *path = StringValuePtr(str);
+    Doc         doc  = self_doc(self);
+    Leaf        leaf;
 
-    doc = self_doc(self);
-    if (0 != (leaf = get_doc_leaf(doc, StringValuePtr(str)))) {
+    if (0 != (leaf = get_doc_leaf(doc, path))) {
         if (NULL != leaf) {
             return Qtrue;
         }
@@ -1440,16 +1448,19 @@ static VALUE doc_exists(VALUE self, VALUE str) {
 static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
     if (rb_block_given_p()) {
         Leaf        save_path[MAX_STACK];
-        Doc         doc  = self_doc(self);
+        Doc         doc;
         const char *path = 0;
         size_t      wlen;
 
+        if (1 <= argc) {
+            path = StringValuePtr(*argv);
+        }
+        doc  = self_doc(self);
         wlen = doc->where - doc->where_path;
         if (0 < wlen) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
-        if (1 <= argc) {
-            path = StringValuePtr(*argv);
+        if (0 != path) {
             if ('/' == *path) {
                 doc->where = doc->where_path;
                 path++;
@@ -1482,11 +1493,10 @@ static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
  * "/one/2"
  */
 static VALUE doc_move(VALUE self, VALUE str) {
-    Doc         doc = self_doc(self);
-    const char *path;
+    const char *path = StringValuePtr(str);
+    Doc         doc  = self_doc(self);
     int         loc;
 
-    path = StringValuePtr(str);
     if ('/' == *path) {
         doc->where = doc->where_path;
         path++;
@@ -1517,17 +1527,21 @@ static VALUE doc_move(VALUE self, VALUE str) {
 static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
     if (rb_block_given_p()) {
         Leaf        save_path[MAX_STACK];
-        Doc         doc  = self_doc(self);
+        Doc         doc;
         const char *path = 0;
         size_t      wlen;
-        Leaf       *where_orig = doc->where;
+        Leaf       *where_orig;
 
-        wlen = doc->where - doc->where_path;
+        if (1 <= argc) {
+            path = StringValuePtr(*argv);
+        }
+        doc        = self_doc(self);
+        where_orig = doc->where;
+        wlen       = doc->where - doc->where_path;
         if (0 < wlen) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
-        if (1 <= argc) {
-            path = StringValuePtr(*argv);
+        if (0 != path) {
             if ('/' == *path) {
                 doc->where = doc->where_path;
                 path++;
@@ -1595,13 +1609,14 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
     if (rb_block_given_p()) {
-        Doc         doc  = self_doc(self);
+        Doc         doc;
         const char *path = 0;
         Leaf        leaf;
 
         if (1 <= argc) {
             path = StringValuePtr(*argv);
         }
+        doc = self_doc(self);
         if (0 != (leaf = get_doc_leaf(doc, path))) {
             each_value(doc, leaf, self);
         }
@@ -1624,19 +1639,23 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
  *   #=> "[2,1]"
  */
 static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
-    Doc         doc = self_doc(self);
+    Doc         doc;
     Leaf        leaf;
     const char *path     = 0;
     const char *filename = 0;
 
     if (1 <= argc) {
         if (Qnil != *argv) {
-            path = StringValuePtr(*argv);
+            StringValue(*argv);
         }
         if (2 <= argc) {
-            filename = StringValuePtr(argv[1]);
+            filename = StringValueCStr(argv[1]);
+        }
+        if (Qnil != *argv) {
+            path = RSTRING_PTR(*argv);
         }
     }
+    doc = self_doc(self);
     if (0 != (leaf = get_doc_leaf(doc, path))) {
         volatile VALUE rjson;
 
@@ -1668,9 +1687,7 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
  *   Oj::Doc.open('[1,2,3]') { |doc| doc.size() }  #=> 4
  */
 static VALUE doc_size(VALUE self) {
-    Doc d;
-    TypedData_Get_Struct(self, struct _doc, &oj_doc_type, d);
-    return ULONG2NUM(d->size);
+    return ULONG2NUM(self_doc(self)->size);
 }
 
 /* @overload close() => nil

data/ext/oj/intern.c

@@ -17,9 +17,6 @@
 #define HASH_SLOT_CNT ((uint64_t)256)
 #define HASH_MASK (HASH_SLOT_CNT - 1)
 
-// almost the Murmur hash algorithm
-#define M 0x5bd1e995
-
 typedef struct _keyVal {
     struct _keyVal *next;
     const char     *key;
@@ -155,40 +152,6 @@ ID oj_attr_intern(const char *key, size_t len) {
     return cache_intern(c, key, 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 ^ oj_hash_seed;
-    uint64_t       k;
-
-    while (key < endless) {
-        k = (uint64_t)*key++;
-        k |= (uint64_t)*key++ << 8;
-        k |= (uint64_t)*key++ << 16;
-        k |= (uint64_t)*key++ << 24;
-
-        k *= M;
-        k ^= k >> 24;
-        h *= M;
-        h ^= k * M;
-    }
-    if (1 < end - key) {
-        uint16_t k16 = (uint16_t)*key++;
-
-        k16 |= (uint16_t)*key++ << 8;
-        h ^= k16 << 8;
-    }
-    if (key < end) {
-        h ^= *key;
-    }
-    h *= M;
-    h ^= h >> 13;
-    h *= M;
-    h ^= h >> 15;
-
-    return h;
-}
-
 static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
     VALUE clas;
     ID    ci = rb_intern(classname);
@@ -264,14 +227,22 @@ static VALUE intern_new_class(VALUE a) {
     KeyVal     bucket = args->bucket;
     VALUE      clas   = resolve_classpath(args->pi, args->key, args->len, args->auto_define, args->error_class);
 
+    if (Qundef == clas) {
+        return clas;
+    }
     if (NULL != bucket->key) {  // not the top slot
-        KeyVal b = OJ_R_ALLOC(struct _keyVal);
-
-        b->next      = NULL;
-        bucket->next = b;
-        bucket       = b;
+        KeyVal b   = (KeyVal)OJ_R_ALLOC_N(char, sizeof(struct _keyVal) + args->len + 1);
+        char  *key = (char *)(b + 1);
+
+        memcpy(key, args->key, args->len);
+        key[args->len] = '\0';
+        b->next        = NULL;
+        b->key         = key;
+        bucket->next   = b;
+        bucket         = b;
+    } else {
+        bucket->key = oj_strndup(args->key, args->len);
     }
-    bucket->key = oj_strndup(args->key, args->len);
     bucket->len = args->len;
     bucket->val = clas;
 
@@ -281,7 +252,7 @@ static VALUE intern_new_class(VALUE a) {
 static KeyVal find_class(KeyVal bucket, const char *key, size_t len, VALUE *clas) {
     if (NULL != bucket->key) {  // not the top slot
         for (KeyVal b = bucket; 0 != b; b = b->next) {
-            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+            if (len == b->len && 0 == memcmp(b->key, key, len)) {
                 *clas = b->val;
                 return NULL;
             }
@@ -292,7 +263,7 @@ static KeyVal find_class(KeyVal bucket, const char *key, size_t len, VALUE *clas
 }
 
 VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int auto_define, VALUE error_class) {
-    uint64_t           h    = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    uint64_t           h    = oj_hash_calc((const uint8_t *)key, len) & HASH_MASK;
     struct _internArgs args = {NULL, key, len, pi, auto_define, error_class};
     VALUE              clas = Qundef;
 
@@ -321,7 +292,7 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
     } else if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
         clas = intern_new_class((VALUE)&args);
     }
-    if (NULL != args.bucket) {  // newly added to the cache
+    if (NULL != args.bucket && Qundef != clas) {  // newly added to the cache
         rb_gc_register_mark_object(clas);
     }
     return clas;