oj 3.12.2 → 3.13.1

data/ext/oj/dump.c

@@ -472,7 +472,7 @@ void oj_dump_time(VALUE obj, Out out, int withZone) {
 void oj_dump_ruby_time(VALUE obj, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_xml_time(VALUE obj, Out out) {
@@ -708,21 +708,18 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
 }
 
 void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
-    rb_encoding *enc = rb_to_encoding(rb_obj_encoding(obj));
+    rb_encoding *enc = rb_enc_get(obj);
 
-    if (rb_utf8_encoding() != enc) {
-        obj = rb_str_conv_enc(obj, enc, rb_utf8_encoding());
+    if (oj_utf8_encoding != enc) {
+        obj = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&obj), (int)RSTRING_LEN(obj), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    // This causes a memory leak in 2.5.1. Maybe in other versions as well.
-    // const char	*sym = rb_id2name(SYM2ID(obj));
+    volatile VALUE s = rb_sym2str(obj);
 
-    volatile VALUE s = rb_sym_to_s(obj);
-
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&s), (int)RSTRING_LEN(s), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 0, 0, out);
 }
 
 static void debug_raise(const char *orig, size_t cnt, int line) {
@@ -760,7 +757,7 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
         if (Yes == out->opts->trace) {
             oj_trace("raw_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
         }
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&jv), (size_t)RSTRING_LEN(jv), out);
+        oj_dump_raw(RSTRING_PTR(jv), (size_t)RSTRING_LEN(jv), out);
     }
 }
 
@@ -958,7 +955,7 @@ void oj_dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 void oj_dump_obj_to_s(VALUE obj, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_raw(const char *str, size_t cnt, Out out) {
@@ -1075,7 +1072,7 @@ void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         assure_size(out, cnt);
     }
-    memcpy(out->cur, rb_string_value_ptr((VALUE *)&rs), cnt);
+    memcpy(out->cur, RSTRING_PTR(rs), cnt);
     out->cur += cnt;
     if (dump_as_string) {
         *out->cur++ = '"';
@@ -1203,7 +1200,7 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         if ((int)sizeof(buf) <= cnt) {
             cnt = sizeof(buf) - 1;
         }
-        memcpy(buf, rb_string_value_ptr((VALUE *)&rstr), cnt);
+        memcpy(buf, RSTRING_PTR(rstr), cnt);
         buf[cnt] = '\0';
     } else {
         cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
@@ -1223,7 +1220,7 @@ int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char
     if (17 <= cnt && (0 == strcmp("0001", buf + cnt - 4) || 0 == strcmp("9999", buf + cnt - 4))) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        strcpy(buf, rb_string_value_ptr((VALUE *)&rstr));
+        strcpy(buf, RSTRING_PTR(rstr));
         cnt = (int)RSTRING_LEN(rstr);
     }
     return cnt;

data/ext/oj/dump_compat.c

@@ -129,7 +129,7 @@ dump_to_json(VALUE obj, Out out) {
 	oj_trace("to_json", obj, __FILE__, __LINE__, 0, TraceRubyOut);
     }
 
-    s = rb_string_value_ptr((VALUE*)&rs);
+    s = RSTRING_PTR(rs);
     len = (int)RSTRING_LEN(rs);
 
     assure_size(out, len + 1);
@@ -635,7 +635,7 @@ dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
 	volatile VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-	strcpy(buf, rb_string_value_ptr((VALUE*)&rstr));
+	strcpy(buf, RSTRING_PTR(rstr));
 	cnt = (int)RSTRING_LEN(rstr);
     }
     assure_size(out, cnt);
@@ -886,7 +886,7 @@ dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
 	assure_size(out, cnt);
     }
-    memcpy(out->cur, rb_string_value_ptr((VALUE*)&rs), cnt);
+    memcpy(out->cur, RSTRING_PTR(rs), cnt);
     out->cur += cnt;
     if (dump_as_string) {
 	*out->cur++ = '"';

data/ext/oj/dump_object.c

@@ -36,7 +36,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         if (oj_bigdecimal_class == clas) {
             volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-            const char *   str  = rb_string_value_ptr((VALUE *)&rstr);
+            const char *   str  = RSTRING_PTR(rstr);
             int            len  = (int)RSTRING_LEN(rstr);
 
             if (No != out->opts->bigdec_as_num) {
@@ -65,7 +65,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
 
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-        const char *   str  = rb_string_value_ptr((VALUE *)&rstr);
+        const char *   str  = RSTRING_PTR(rstr);
         int            len  = (int)RSTRING_LEN(rstr);
 
         if (0 == strcasecmp("Infinity", str)) {
@@ -195,7 +195,7 @@ static void dump_str_class(VALUE obj, VALUE clas, int depth, Out out) {
     if (Qundef != clas && rb_cString != clas) {
         dump_obj_attrs(obj, clas, 0, depth, out);
     } else {
-        const char *s   = rb_string_value_ptr((VALUE *)&obj);
+        const char *s   = RSTRING_PTR(obj);
         size_t      len = (int)RSTRING_LEN(obj);
         char        s1  = s[1];
 
@@ -208,9 +208,9 @@ 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_sym_to_s(obj);
+    volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&s), (int)RSTRING_LEN(s), 1, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 1, 0, out);
 }
 
 static int hash_cb(VALUE key, VALUE value, VALUE ov) {
@@ -414,7 +414,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
         if (Qundef == v || T_STRING != rb_type(v)) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.");
         } else {
-            const char *s    = rb_string_value_ptr((VALUE *)&v);
+            const char *s    = RSTRING_PTR(v);
             int         len  = (int)RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
@@ -532,7 +532,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
         *out->cur++ = 'f';
         *out->cur++ = '"';
         *out->cur++ = ':';
-        oj_dump_cstr(rb_string_value_ptr((VALUE *)&obj), (int)RSTRING_LEN(obj), 0, 0, out);
+        oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
         break;
     case T_ARRAY:
         assure_size(out, d2 * out->indent + 14);
@@ -694,9 +694,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
-            volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+            volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
-            name = rb_string_value_ptr((VALUE *)&s);
+            name = RSTRING_PTR(s);
             len  = (int)RSTRING_LEN(s);
             size = len + 3;
             assure_size(out, size);

data/ext/oj/dump_strict.c

@@ -98,7 +98,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
             if ((int)sizeof(buf) <= cnt) {
                 cnt = sizeof(buf) - 1;
             }
-            memcpy(buf, rb_string_value_ptr((VALUE *)&rstr), cnt);
+            memcpy(buf, RSTRING_PTR(rstr), cnt);
             buf[cnt] = '\0';
         } else {
             cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
@@ -304,7 +304,7 @@ static void dump_data_strict(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
     } else {
         raise_strict(obj);
     }
@@ -316,7 +316,7 @@ static void dump_data_null(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
     } else {
         oj_dump_nil(Qnil, depth, out, false);
     }

data/ext/oj/err.h

@@ -4,12 +4,31 @@
 #ifndef OJ_ERR_H
 #define OJ_ERR_H
 
+#include <errno.h>
 #include "ruby.h"
+
 // Needed to silence 2.4.0 warnings.
 #ifndef NORETURN
 #define NORETURN(x) x
 #endif
 
+#define OJ_ERR_START		300
+
+typedef enum {
+    OJ_OK		= 0,
+    OJ_ERR_MEMORY	= ENOMEM,
+    OJ_ERR_PARSE	= OJ_ERR_START,
+    OJ_ERR_READ,
+    OJ_ERR_WRITE,
+    OJ_ERR_OVERFLOW,
+    OJ_ERR_ARG,
+    OJ_ERR_TOO_MANY,
+    OJ_ERR_TYPE,
+    OJ_ERR_KEY,
+    OJ_ABORT,
+    OJ_ERR_LAST,
+} ojStatus;
+
 #define set_error(err, eclas, msg, json, current) \
     _oj_err_set_with_location(err, eclas, msg, json, current, FILE, LINE)
 

data/ext/oj/extconf.rb

@@ -30,6 +30,10 @@ have_func('rb_ivar_foreach')
 have_func('rb_gc_mark_movable')
 have_func('stpcpy')
 have_func('pthread_mutex_init')
+have_func('rb_enc_associate')
+have_func('rb_ext_ractor_safe', 'ruby.h')
+# rb_hash_bulk_insert is deep down in a header not included in normal build and that seems to fool have_func.
+have_func('rb_hash_bulk_insert', 'ruby.h') unless '2' == version[0] && '6' == version[1]
 
 dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
 

data/ext/oj/fast.c

@@ -200,9 +200,7 @@ static VALUE leaf_value(Doc doc, Leaf leaf) {
             break;
         case T_ARRAY: return leaf_array_value(doc, leaf); break;
         case T_HASH: return leaf_hash_value(doc, leaf); break;
-        default:
-            rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype);
-            break;
+        default: rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype); break;
         }
     }
     return leaf->value;
@@ -773,7 +771,7 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.doc = doc;
 #if IS_WINDOWS
     // assume a 1M stack and give half to ruby
-    pi.stack_min = (void *)((char *)&pi - (512 * 1024));
+    pi.stack_min = (void*)((char*)&pi - (512 * 1024));
 #else
     {
         struct rlimit lim;
@@ -825,9 +823,7 @@ static Leaf get_doc_leaf(Doc doc, const char *path) {
             size_t cnt = doc->where - doc->where_path;
 
             if (MAX_STACK <= cnt) {
-                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                         "Path too deep. Limit is %d levels.",
-                         MAX_STACK);
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
             }
             memcpy(stack, doc->where_path, sizeof(Leaf) * (cnt + 1));
             lp = stack + cnt;
@@ -868,9 +864,7 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
     Leaf leaf = *lp;
 
     if (MAX_STACK <= lp - stack) {
-        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                 "Path too deep. Limit is %d levels.",
-                 MAX_STACK);
+        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
     }
     if ('\0' != *path) {
         if ('.' == *path && '.' == *(path + 1)) {
@@ -946,9 +940,7 @@ static void each_leaf(Doc doc, VALUE self) {
 
             doc->where++;
             if (MAX_STACK <= doc->where - doc->where_path) {
-                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                         "Path too deep. Limit is %d levels.",
-                         MAX_STACK);
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
             }
             do {
                 *doc->where = e;
@@ -964,9 +956,7 @@ static void each_leaf(Doc doc, VALUE self) {
 
 static int move_step(Doc doc, const char *path, int loc) {
     if (MAX_STACK <= doc->where - doc->where_path) {
-        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                 "Path too deep. Limit is %d levels.",
-                 MAX_STACK);
+        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
     }
     if ('\0' == *path) {
         loc = 0;
@@ -1264,7 +1254,6 @@ static VALUE doc_path(VALUE self) {
     return doc_where(self);
 }
 
-
 /* @overload local_key() => String, Fixnum, nil
  *
  * Returns the final key to the current location.

data/ext/oj/intern.c

@@ -0,0 +1,398 @@
+// Copyright (c) 2011, 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "intern.h"
+
+#include <stdint.h>
+
+#if HAVE_PTHREAD_MUTEX_INIT
+#include <pthread.h>
+#endif
+#include "parse.h"
+
+#define HASH_SLOT_CNT ((uint32_t)8192)
+#define HASH_MASK (HASH_SLOT_CNT - 1)
+
+typedef struct _keyVal {
+    struct _keyVal *next;
+    const char *    key;
+    size_t          len;
+    VALUE           val;
+} * KeyVal;
+
+typedef struct _hash {
+    struct _keyVal slots[HASH_SLOT_CNT];
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_t mutex;
+#else
+    VALUE mutex;
+#endif
+} * Hash;
+
+struct _hash class_hash;
+struct _hash str_hash;
+struct _hash sym_hash;
+struct _hash attr_hash;
+
+// almost the Murmur hash algorithm
+#define M 0x5bd1e995
+#define C1 0xCC9E2D51
+#define C2 0x1B873593
+#define N 0xE6546B64
+
+static uint32_t hash_calc(const uint8_t *key, size_t len) {
+    const uint8_t *end     = key + len;
+    const uint8_t *endless = key + (len & 0xFFFFFFFC);
+    uint32_t       h       = (uint32_t)len;
+    uint32_t       k;
+
+    while (key < endless) {
+        k = (uint32_t)*key++;
+        k |= (uint32_t)*key++ << 8;
+        k |= (uint32_t)*key++ << 16;
+        k |= (uint32_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;
+}
+
+void oj_hash_init() {
+    memset(class_hash.slots, 0, sizeof(class_hash.slots));
+    memset(str_hash.slots, 0, sizeof(str_hash.slots));
+    memset(sym_hash.slots, 0, sizeof(sym_hash.slots));
+    memset(attr_hash.slots, 0, sizeof(attr_hash.slots));
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_init(&class_hash.mutex, NULL);
+    pthread_mutex_init(&str_hash.mutex, NULL);
+    pthread_mutex_init(&sym_hash.mutex, NULL);
+    pthread_mutex_init(&attr_hash.mutex, NULL);
+#else
+    class_hash.mutex = rb_mutex_new();
+    rb_gc_register_address(&class_hash.mutex);
+    str_hash.mutex = rb_mutex_new();
+    rb_gc_register_address(&str_hash.mutex);
+    sym_hash.mutex = rb_mutex_new();
+    rb_gc_register_address(&sym_hash.mutex);
+    attr_hash.mutex = rb_mutex_new();
+    rb_gc_register_address(&attr_hash.mutex);
+#endif
+}
+
+void oj_hash_print() {
+    uint32_t i;
+    KeyVal   b;
+
+    for (i = 0; i < HASH_SLOT_CNT; i++) {
+        printf("%4d:", i);
+        for (b = class_hash.slots + i; 0 != b && 0 != b->key; b = b->next) {
+            printf(" %s", b->key);
+        }
+        printf("\n");
+    }
+}
+
+void oj_hash_sizes() {
+    uint32_t i;
+    KeyVal   b;
+    int      max = 0;
+    int      min = 1000000;
+
+    for (i = 0; i < HASH_SLOT_CNT; i++) {
+        int cnt = 0;
+
+        for (b = str_hash.slots + i; 0 != b && 0 != b->key; b = b->next) {
+            cnt++;
+        }
+        // printf(" %4d\n", cnt);
+        if (max < cnt) {
+            max = cnt;
+        }
+        if (cnt < min) {
+            min = cnt;
+        }
+    }
+    printf("min: %d  max: %d\n", min, max);
+}
+
+VALUE
+oj_str_intern(const char *key, size_t len) {
+    uint32_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    KeyVal   bucket = str_hash.slots + h;
+    KeyVal   b;
+
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_lock(&str_hash.mutex);
+#else
+    rb_mutex_lock(str_hash.mutex);
+#endif
+    if (NULL != bucket->key) {  // not the top slot
+        for (b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+#if HAVE_PTHREAD_MUTEX_INIT
+                pthread_mutex_unlock(&str_hash.mutex);
+#else
+                rb_mutex_unlock(str_hash.mutex);
+#endif
+                return b->val;
+            }
+            bucket = b;
+        }
+        b            = ALLOC(struct _keyVal);
+        b->next      = NULL;
+        bucket->next = b;
+        bucket       = b;
+    }
+    bucket->key = oj_strndup(key, len);
+    bucket->len = len;
+    bucket->val = rb_utf8_str_new(key, len);
+    bucket->val = rb_str_freeze(bucket->val);
+    rb_gc_register_address(&bucket->val);
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_unlock(&str_hash.mutex);
+#else
+    rb_mutex_unlock(str_hash.mutex);
+#endif
+    return bucket->val;
+}
+
+VALUE
+oj_sym_intern(const char *key, size_t len) {
+    uint32_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    KeyVal   bucket = sym_hash.slots + h;
+    KeyVal   b;
+
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_lock(&sym_hash.mutex);
+#else
+    rb_mutex_lock(sym_hash.mutex);
+#endif
+    if (NULL != bucket->key) {  // not the top slot
+        for (b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+#if HAVE_PTHREAD_MUTEX_INIT
+                pthread_mutex_unlock(&sym_hash.mutex);
+#else
+                rb_mutex_unlock(sym_hash.mutex);
+#endif
+                return b->val;
+            }
+            bucket = b;
+        }
+        b            = ALLOC(struct _keyVal);
+        b->next      = NULL;
+        bucket->next = b;
+        bucket       = b;
+    }
+    bucket->key = oj_strndup(key, len);
+    bucket->len = len;
+    bucket->val = ID2SYM(rb_intern3(key, len, oj_utf8_encoding));
+    rb_gc_register_address(&bucket->val);
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_unlock(&sym_hash.mutex);
+#else
+    rb_mutex_unlock(sym_hash.mutex);
+#endif
+    return bucket->val;
+}
+
+static ID form_attr(const char *key, size_t klen) {
+    char attr[256];
+    ID   var_id;
+
+    if ((int)sizeof(attr) <= klen + 2) {
+        char *buf = ALLOC_N(char, klen + 2);
+
+        if ('~' == *key) {
+            memcpy(buf, key + 1, klen - 1);
+            buf[klen - 1] = '\0';
+        } else {
+            *buf = '@';
+            memcpy(buf + 1, key, klen);
+            buf[klen + 1] = '\0';
+        }
+        var_id = rb_intern(buf);
+        xfree(buf);
+    } else {
+        if ('~' == *key) {
+            memcpy(attr, key + 1, klen - 1);
+            attr[klen - 1] = '\0';
+        } else {
+            *attr = '@';
+            memcpy(attr + 1, key, klen);
+            attr[klen + 1] = '\0';
+        }
+        var_id = rb_intern(attr);
+    }
+    return var_id;
+}
+
+ID oj_attr_intern(const char *key, size_t len) {
+    uint32_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    KeyVal   bucket = attr_hash.slots + h;
+    KeyVal   b;
+
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_lock(&attr_hash.mutex);
+#else
+    rb_mutex_lock(attr_hash.mutex);
+#endif
+    if (NULL != bucket->key) {  // not the top slot
+        for (b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+#if HAVE_PTHREAD_MUTEX_INIT
+                pthread_mutex_unlock(&attr_hash.mutex);
+#else
+                rb_mutex_unlock(attr_hash.mutex);
+#endif
+                return (ID)b->val;
+            }
+            bucket = b;
+        }
+        b            = ALLOC(struct _keyVal);
+        b->next      = NULL;
+        bucket->next = b;
+        bucket       = b;
+    }
+    bucket->key = oj_strndup(key, len);
+    bucket->len = len;
+    bucket->val = (VALUE)form_attr(key, len);
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_unlock(&attr_hash.mutex);
+#else
+    rb_mutex_unlock(attr_hash.mutex);
+#endif
+    return (ID)bucket->val;
+}
+
+static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
+    VALUE clas;
+    ID    ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+        clas = rb_const_get_at(mod, ci);
+    } else if (auto_define) {
+        clas = rb_define_class_under(mod, classname, oj_bag_class);
+    } else {
+        clas = Qundef;
+    }
+    return clas;
+}
+
+static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
+    char        class_name[1024];
+    VALUE       clas;
+    char *      end = class_name + sizeof(class_name) - 1;
+    char *      s;
+    const char *n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; 0 < len; n++, len--) {
+        if (':' == *n) {
+            *s = '\0';
+            n++;
+            len--;
+            if (':' != *n) {
+                return Qundef;
+            }
+            if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+                return Qundef;
+            }
+            s = class_name;
+        } else if (end <= s) {
+            return Qundef;
+        } else {
+            *s++ = *n;
+        }
+    }
+    *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 (Qnil != error_class) {
+            pi->err_class = error_class;
+        }
+    }
+    return clas;
+}
+
+VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int auto_define, VALUE error_class) {
+    uint32_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    KeyVal   bucket = class_hash.slots + h;
+    KeyVal   b;
+
+    if (safe) {
+#if HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_lock(&class_hash.mutex);
+#else
+        rb_mutex_lock(class_hash.mutex);
+#endif
+        if (NULL != bucket->key) {  // not the top slot
+            for (b = bucket; 0 != b; b = b->next) {
+                if (len == b->len && 0 == strncmp(b->key, key, len)) {
+#if HAVE_PTHREAD_MUTEX_INIT
+                    pthread_mutex_unlock(&class_hash.mutex);
+#else
+                    rb_mutex_unlock(class_hash.mutex);
+#endif
+                    return b->val;
+                }
+                bucket = b;
+            }
+            b            = ALLOC(struct _keyVal);
+            b->next      = NULL;
+            bucket->next = b;
+            bucket       = b;
+        }
+        bucket->key = oj_strndup(key, len);
+        bucket->len = len;
+        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
+#if HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_unlock(&class_hash.mutex);
+#else
+        rb_mutex_unlock(class_hash.mutex);
+#endif
+    } else {
+        if (NULL != bucket->key) {
+            for (b = bucket; 0 != b; b = b->next) {
+                if (len == b->len && 0 == strncmp(b->key, key, len)) {
+                    return (ID)b->val;
+                }
+                bucket = b;
+            }
+            b            = ALLOC(struct _keyVal);
+            b->next      = NULL;
+            bucket->next = b;
+            bucket       = b;
+        }
+        bucket->key = oj_strndup(key, len);
+        bucket->len = len;
+        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
+    }
+    return bucket->val;
+}
+
+char *oj_strndup(const char *s, size_t len) {
+    char *d = ALLOC_N(char, len + 1);
+
+    memcpy(d, s, len);
+    d[len] = '\0';
+
+    return d;
+}