oj 3.17.6 → 3.17.8

data/ext/oj/saj2.c

@@ -33,9 +33,30 @@ static void push_key(Saj d, VALUE key) {
     d->tail++;
 }
 
+static VALUE pop_key(Saj d) {
+    if (d->tail <= d->keys) {
+        rb_raise(rb_eIndexError, "accessing key stack");
+    }
+    d->tail--;
+
+    return *d->tail;
+}
+
 static void noop(ojParser p) {
 }
 
+static void open_push_key(ojParser p) {
+    push_key((Saj)p->ctx, get_key(p));
+}
+
+static void close_pop_key(ojParser p) {
+    Saj d = (Saj)p->ctx;
+
+    if (d->keys < d->tail) {
+        d->tail--;
+    }
+}
+
 static void open_object(ojParser p) {
     rb_funcall(((Saj)p->ctx)->handler, oj_hash_start_id, 1, Qnil);
 }
@@ -89,11 +110,7 @@ static void close_object(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_hash_end_id, 1, key);
 }
@@ -103,11 +120,7 @@ static void close_object_loc(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_hash_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
 }
@@ -117,11 +130,7 @@ static void close_array(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_array_end_id, 1, key);
 }
@@ -131,11 +140,7 @@ static void close_array_loc(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_array_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
 }
@@ -380,10 +385,15 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
         return d->handler;
     }
     if (0 == strcmp(key, "handler=")) {
+        int hash_start  = rb_respond_to(value, oj_hash_start_id);
+        int hash_end    = rb_respond_to(value, oj_hash_end_id);
+        int array_start = rb_respond_to(value, oj_array_start_id);
+        int array_end   = rb_respond_to(value, oj_array_end_id);
+
         d->tail    = d->keys;
         d->handler = value;
         reset(p);
-        if (rb_respond_to(value, oj_hash_start_id)) {
+        if (hash_start) {
             if (1 == rb_obj_method_arity(value, oj_hash_start_id)) {
                 p->funcs[TOP_FUN].open_object    = open_object;
                 p->funcs[ARRAY_FUN].open_object  = open_object;
@@ -393,8 +403,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].open_object  = open_object_loc;
                 p->funcs[OBJECT_FUN].open_object = open_object_loc_key;
             }
+        } else if (hash_end) {
+            p->funcs[OBJECT_FUN].open_object = open_push_key;
         }
-        if (rb_respond_to(value, oj_array_start_id)) {
+        if (array_start) {
             if (1 == rb_obj_method_arity(value, oj_array_start_id)) {
                 p->funcs[TOP_FUN].open_array    = open_array;
                 p->funcs[ARRAY_FUN].open_array  = open_array;
@@ -404,8 +416,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].open_array  = open_array_loc;
                 p->funcs[OBJECT_FUN].open_array = open_array_loc_key;
             }
+        } else if (array_end) {
+            p->funcs[OBJECT_FUN].open_array = open_push_key;
         }
-        if (rb_respond_to(value, oj_hash_end_id)) {
+        if (hash_end) {
             if (1 == rb_obj_method_arity(value, oj_hash_end_id)) {
                 p->funcs[TOP_FUN].close_object    = close_object;
                 p->funcs[ARRAY_FUN].close_object  = close_object;
@@ -415,8 +429,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].close_object  = close_object_loc;
                 p->funcs[OBJECT_FUN].close_object = close_object_loc;
             }
+        } else if (hash_start) {
+            p->funcs[OBJECT_FUN].close_object = close_pop_key;
         }
-        if (rb_respond_to(value, oj_array_end_id)) {
+        if (array_end) {
             if (1 == rb_obj_method_arity(value, oj_array_end_id)) {
                 p->funcs[TOP_FUN].close_array    = close_array;
                 p->funcs[ARRAY_FUN].close_array  = close_array;
@@ -426,6 +442,8 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].close_array  = close_array_loc;
                 p->funcs[OBJECT_FUN].close_array = close_array_loc;
             }
+        } else if (array_start) {
+            p->funcs[OBJECT_FUN].close_array = close_pop_key;
         }
         if (rb_respond_to(value, oj_add_value_id)) {
             if (2 == rb_obj_method_arity(value, oj_add_value_id)) {
@@ -547,10 +565,8 @@ static void mark(ojParser p) {
     if (Qnil != d->handler) {
         rb_gc_mark(d->handler);
     }
-    if (!d->cache_keys) {
-        for (kp = d->keys; kp < d->tail; kp++) {
-            rb_gc_mark(*kp);
-        }
+    for (kp = d->keys; kp < d->tail; kp++) {
+        rb_gc_mark(*kp);
     }
 }
 

data/ext/oj/simd.h

@@ -98,10 +98,10 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #elif defined(__GNUC__) || defined(__clang__)
 // GCC/Clang: check for header availability and include them
 // We include headers but use target attributes to enable instructions per-function
-// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable
-#if __has_include(<cpuid.h>)
+// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable.
+// cpuid.h is available on all GCC since 4.3 and all Clang versions, so include
+// it unconditionally rather than gating on __has_include (which GCC < 5 lacks).
 #include <cpuid.h>
-#endif
 #if defined(__SSE4_2__) || defined(__SSE2__)
 // If any SSE is enabled globally, x86intrin.h should be available
 #include <x86intrin.h>
@@ -109,6 +109,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #define HAVE_SIMD_SSE2 1
 #else
 // Try to include headers anyway for target attribute functions
+#ifdef __has_include
 #if __has_include(<x86intrin.h>)
 #include <x86intrin.h>
 #define HAVE_SIMD_SSE4_2 1
@@ -123,6 +124,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #endif
 #endif
 #endif
+#endif
 
 // Target attribute macros for function-level SIMD enabling
 #if defined(__clang__) || defined(__GNUC__)

data/ext/oj/sparse.c

@@ -274,6 +274,10 @@ static void read_escaped_str(ParseInfo pi) {
                 buf_cleanup(&buf);
                 return;
             }
+        } else if ((unsigned char)c < 0x20 && (StrictMode == pi->options.mode || CompatMode == pi->options.mode)) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+            buf_cleanup(&buf);
+            return;
         } else {
             buf_append(&buf, c);
         }
@@ -341,6 +345,9 @@ static void read_str(ParseInfo pi) {
             read_escaped_str(pi);
             reader_release(&pi->rd);
             return;
+        } else if ((unsigned char)c < 0x20 && (StrictMode == pi->options.mode || CompatMode == pi->options.mode)) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+            return;
         }
     }
     if (0 == parent) {  // simple add

data/ext/oj/stream_writer.c

@@ -16,6 +16,9 @@ static void stream_writer_free(void *ptr) {
         return;
     }
     sw = (StreamWriter)ptr;
+    if (NULL != sw->sw.out.circ_cache) {
+        oj_cache8_delete(sw->sw.out.circ_cache);
+    }
     oj_options_release(&sw->sw.opts);
     OJ_R_FREE(sw->sw.out.buf);
     OJ_R_FREE(sw->sw.types);

data/ext/oj/strict.c

@@ -47,7 +47,29 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
     return rkey;
 }
 
+// With the default Hash class the pairs of the just closed hash sit on top
+// of the pair buffer; build the Hash in one bulk insert with the final size
+// known instead of one rb_hash_aset per pair (which converts the small
+// ar_table to an st_table mid-insertion for hashes above 8 entries).
 static void hash_end(ParseInfo pi) {
+    if (Qnil == pi->options.hash_class) {
+        ValStack       stack = &pi->stack;
+        Val            hash  = stack_peek(stack);
+        size_t         cnt   = hash->pcnt;
+        volatile VALUE h;
+
+#if HAVE_RB_HASH_NEW_CAPA
+        h = rb_hash_new_capa((long)(cnt / 2));
+#else
+        h = rb_hash_new();
+#endif
+        if (0 < cnt) {
+            rb_hash_bulk_insert((long)cnt, stack->pairs + stack->pcnt - cnt, h);
+            stack->pcnt -= cnt;
+            hash->pcnt = 0;
+        }
+        hash->val = h;
+    }
     TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
@@ -84,13 +106,19 @@ static VALUE start_hash(ParseInfo pi) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
-    return rb_hash_new();
+    // The Hash is built at hash_end from the buffered pairs.
+    return Qundef;
 }
 
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), rstr);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
 }
 
@@ -101,12 +129,22 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), v);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, v);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), value);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 

data/ext/oj/string_writer.c

@@ -169,6 +169,11 @@ void oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
             *out->cur++ = ':';
         }
     }
+    if (NULL != out->circ_cache) {
+        oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
+    }
+    out->circ_cnt = 0;
     switch (out->opts->mode) {
     case StrictMode: oj_dump_strict_val(val, sw->depth, out); break;
     case NullMode: oj_dump_null_val(val, sw->depth, out); break;
@@ -178,6 +183,10 @@ void oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
     case CustomMode: oj_dump_custom_val(val, sw->depth, out, true); break;
     default: oj_dump_custom_val(val, sw->depth, out, true); break;
     }
+    if (NULL != out->circ_cache) {
+        oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
+    }
 }
 
 void oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
@@ -203,16 +212,17 @@ void oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
 
 void oj_str_writer_pop(StrWriter sw) {
     long     size;
-    DumpType type = sw->types[sw->depth];
+    DumpType type;
 
     if (sw->keyWritten) {
         sw->keyWritten = 0;
         rb_raise(rb_eStandardError, "Can not pop after writing a key but no value.");
     }
-    sw->depth--;
-    if (0 > sw->depth) {
+    if (0 >= sw->depth) {
         rb_raise(rb_eStandardError, "Can not pop with no open array or object.");
     }
+    type = sw->types[sw->depth];
+    sw->depth--;
     size = sw->depth * sw->out.indent + 2;
     assure_size(&sw->out, size);
     fill_indent(&sw->out, sw->depth);
@@ -241,6 +251,10 @@ static void string_writer_free(void *ptr) {
     }
     sw = (StrWriter)ptr;
 
+    if (NULL != sw->out.circ_cache) {
+        oj_cache8_delete(sw->out.circ_cache);
+        sw->out.circ_cache = NULL;
+    }
     oj_out_free(&sw->out);
     oj_options_release(&sw->opts);
 

data/ext/oj/usual.c

@@ -49,7 +49,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_str_intern(rb_utf8_str_new(str, len));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -80,6 +85,9 @@ static VALUE resolve_classname(VALUE mod, const char *classname, bool auto_defin
 
     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 {
@@ -172,9 +180,9 @@ static VALUE str_key(ojParser p, Key kp) {
 
 static VALUE sym_key(ojParser p, Key kp) {
     if ((size_t)kp->len < sizeof(kp->buf)) {
-        return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->buf, kp->len)));
+        return form_sym(kp->buf, kp->len);
     }
-    return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->key, kp->len)));
+    return form_sym(kp->key, kp->len);
 }
 
 static ID get_attr_id(ojParser p, Key kp) {
@@ -809,7 +817,7 @@ static VALUE opt_class_cache_set(ojParser p, VALUE value) {
 
     if (Qtrue == value) {
         if (NULL == d->class_cache) {
-            d->class_cache = cache_create(0, form_class_auto, MISS_AUTO == d->miss_class, false);
+            d->class_cache = cache_create(0, form_class_auto, true, false);
         }
     } else if (NULL != d->class_cache) {
         cache_free(d->class_cache);

data/ext/oj/val_stack.c

@@ -3,8 +3,6 @@
 
 #include "val_stack.h"
 
-#include <string.h>
-
 #include "odd.h"
 #include "oj.h"
 
@@ -15,12 +13,13 @@ static void stack_mark(void *ptr) {
     if (NULL == ptr) {
         return;
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_lock(&stack->mutex);
-#else
-    rb_mutex_lock(stack->mutex);
-    rb_gc_mark(stack->mutex);
-#endif
+    {
+        size_t i;
+
+        for (i = 0; i < stack->pcnt; i++) {
+            rb_gc_mark(stack->pairs[i]);
+        }
+    }
     for (v = stack->head; v < stack->tail; v++) {
         if (Qnil != v->val && Qundef != v->val) {
             rb_gc_mark(v->val);
@@ -39,11 +38,6 @@ static void stack_mark(void *ptr) {
             }
         }
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_unlock(&stack->mutex);
-#else
-    rb_mutex_unlock(stack->mutex);
-#endif
 }
 
 static const rb_data_type_t oj_stack_type = {
@@ -59,18 +53,12 @@ static const rb_data_type_t oj_stack_type = {
 
 VALUE
 oj_stack_init(ValStack stack) {
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    int err;
-
-    if (0 != (err = pthread_mutex_init(&stack->mutex, 0))) {
-        rb_raise(rb_eException, "failed to initialize a mutex. %s", strerror(err));
-    }
-#else
-    stack->mutex = rb_mutex_new();
-#endif
     stack->head            = stack->base;
     stack->end             = stack->base + sizeof(stack->base) / sizeof(struct _val);
     stack->tail            = stack->head;
+    stack->pairs           = stack->pbase;
+    stack->pcnt            = 0;
+    stack->pend            = sizeof(stack->pbase) / sizeof(VALUE);
     stack->head->val       = Qundef;
     stack->head->key       = NULL;
     stack->head->key_val   = Qundef;
@@ -79,6 +67,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clas      = Qundef;
     stack->head->klen      = 0;
     stack->head->clen      = 0;
+    stack->head->pcnt      = 0;
     stack->head->next      = NEXT_NONE;
 
     return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);

data/ext/oj/val_stack.h

@@ -9,9 +9,6 @@
 #include "mem.h"
 #include "odd.h"
 #include "ruby.h"
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-#include <pthread.h>
-#endif
 
 #define STACK_INC 64
 
@@ -37,22 +34,27 @@ typedef struct _val {
     OddArgs        odd_args;
     size_t         klen;
     size_t         clen;
+    size_t         pcnt;  // VALUEs this open hash holds in the stack pair buffer
     char           next;  // ValNext
     char           k1;    // first original character in the key
     char           kalloc;
 } *Val;
 
+#define PAIR_BASE_CNT 64
+
 typedef struct _valStack {
     struct _val base[STACK_INC];
-    Val         head;  // current stack
-    Val         end;   // stack end
-    Val         tail;  // pointer to one past last element name on stack
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_t mutex;
-#else
-    VALUE mutex;
-#endif
-
+    VALUE       pbase[PAIR_BASE_CNT];  // initial buffer for pairs
+    // Flat key/value pair buffer for hash modes that build each Hash in one
+    // rb_hash_bulk_insert at the closing brace instead of one rb_hash_aset
+    // per pair. Nesting is strictly LIFO so each open hash's pairs occupy
+    // the top of the buffer; the per-hash count lives in its Val's clen.
+    VALUE *pairs;
+    size_t pcnt;  // number of live VALUEs in pairs
+    size_t pend;  // capacity of pairs in VALUEs
+    Val    head;  // current stack
+    Val    end;   // stack end
+    Val    tail;  // pointer to one past last element name on stack
 } *ValStack;
 
 extern VALUE oj_stack_init(ValStack stack);
@@ -76,6 +78,11 @@ inline static void stack_cleanup(ValStack stack) {
         OJ_R_FREE(stack->head);
         stack->head = NULL;
     }
+    if (stack->pbase != stack->pairs) {
+        OJ_R_FREE(stack->pairs);
+        stack->pairs = NULL;
+    }
+    stack->pcnt = 0;
 }
 
 inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
@@ -86,8 +93,8 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
         const char *old  = (const char *)stack->head;
         size_t      i;
 
-        // A realloc can trigger a GC so make sure it happens outside the lock
-        // but lock before changing pointers.
+        // A realloc can trigger a GC that marks the stack, so change the
+        // pointers only after it returns.
         if (stack->base == stack->head) {
             head = OJ_R_ALLOC_N(struct _val, len + STACK_INC);
             memcpy(head, stack->base, sizeof(struct _val) * len);
@@ -101,19 +108,9 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
                 head[i].key = head[i].karray;
             }
         }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_lock(&stack->mutex);
-#else
-        rb_mutex_lock(stack->mutex);
-#endif
         stack->head = head;
         stack->tail = stack->head + toff;
         stack->end  = stack->head + len + STACK_INC;
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_unlock(&stack->mutex);
-#else
-        rb_mutex_unlock(stack->mutex);
-#endif
     }
     stack->tail->val       = val;
     stack->tail->next      = next;
@@ -124,6 +121,7 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
     stack->tail->key_val   = Qundef;
     stack->tail->clen      = 0;
     stack->tail->klen      = 0;
+    stack->tail->pcnt      = 0;
     stack->tail->kalloc    = 0;
     stack->tail++;
 }
@@ -165,6 +163,29 @@ inline static Val stack_pop(ValStack stack) {
     return 0;
 }
 
+// Append one key/value pair to the pair buffer. The same GC discipline as
+// stack_push: the allocation can trigger a GC that marks the pairs, so the
+// buffer pointer only changes after it returns.
+inline static void stack_pair_push(ValStack stack, VALUE key, VALUE value) {
+    if (stack->pend <= stack->pcnt + 2) {
+        size_t cnt = stack->pend * 2;
+        VALUE *pairs;
+
+        if (stack->pbase == stack->pairs) {
+            pairs = OJ_R_ALLOC_N(VALUE, cnt);
+            memcpy(pairs, stack->pairs, sizeof(VALUE) * stack->pcnt);
+        } else {
+            pairs = stack->pairs;
+            OJ_R_REALLOC_N(pairs, VALUE, cnt);
+        }
+        stack->pairs = pairs;
+        stack->pend  = cnt;
+    }
+    stack->pairs[stack->pcnt]     = key;
+    stack->pairs[stack->pcnt + 1] = value;
+    stack->pcnt += 2;
+}
+
 extern const char *oj_stack_next_string(ValNext n);
 
 #endif /* OJ_VAL_STACK_H */

data/ext/oj/wab.c

@@ -40,6 +40,7 @@ static VALUE resolve_wab_uuid_class(void) {
         volatile VALUE wab_module;
 
         wab_uuid_clas = Qnil;
+        rb_gc_register_address(&wab_uuid_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("WAB"))) {
             wab_module = rb_const_get_at(rb_cObject, rb_intern("WAB"));
             if (rb_const_defined_at(wab_module, rb_intern("UUID"))) {
@@ -53,6 +54,7 @@ static VALUE resolve_wab_uuid_class(void) {
 static VALUE resolve_uri_class(void) {
     if (Qundef == uri_clas) {
         uri_clas = Qnil;
+        rb_gc_register_address(&uri_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("URI"))) {
             uri_clas = rb_const_get_at(rb_cObject, rb_intern("URI"));
         }
@@ -65,6 +67,7 @@ static VALUE resolve_uri_http_class(void) {
         volatile VALUE uri_module;
 
         uri_http_clas = Qnil;
+        rb_gc_register_address(&uri_http_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("URI"))) {
             uri_module = rb_const_get_at(rb_cObject, rb_intern("URI"));
             if (rb_const_defined_at(uri_module, rb_intern("HTTP"))) {