oj 3.13.23 → 3.16.10

data/ext/oj/trace.h

@@ -17,12 +17,39 @@ typedef enum {
 
 struct _parseInfo;
 
-extern void
-            oj_trace(const char *func, VALUE obj, const char *file, int line, int depth, TraceWhere where);
+extern void oj_trace(const char *func, VALUE obj, const char *file, int line, int depth, TraceWhere where);
 extern void oj_trace_parse_in(const char *func, struct _parseInfo *pi, const char *file, int line);
-extern void
-            oj_trace_parse_call(const char *func, struct _parseInfo *pi, const char *file, int line, VALUE obj);
+extern void oj_trace_parse_call(const char *func, struct _parseInfo *pi, const char *file, int line, VALUE obj);
 extern void oj_trace_parse_hash_end(struct _parseInfo *pi, const char *file, int line);
 extern void oj_trace_parse_array_end(struct _parseInfo *pi, const char *file, int line);
 
+#ifdef OJ_ENABLE_TRACE_LOG
+#define TRACE(option, func, obj, depth, where)                 \
+    if (RB_UNLIKELY(Yes == option)) {                          \
+        oj_trace(func, obj, __FILE__, __LINE__, depth, where); \
+    }
+#define TRACE_PARSE_IN(option, func, pi)                 \
+    if (RB_UNLIKELY(Yes == option)) {                    \
+        oj_trace_parse_in(func, pi, __FILE__, __LINE__); \
+    }
+#define TRACE_PARSE_CALL(option, func, pi, obj)                 \
+    if (RB_UNLIKELY(Yes == option)) {                           \
+        oj_trace_parse_call(func, pi, __FILE__, __LINE__, obj); \
+    }
+#define TRACE_PARSE_HASH_END(option, pi)                 \
+    if (RB_UNLIKELY(Yes == option)) {                    \
+        oj_trace_parse_hash_end(pi, __FILE__, __LINE__); \
+    }
+#define TRACE_PARSE_ARRAY_END(option, pi)                 \
+    if (RB_UNLIKELY(Yes == option)) {                     \
+        oj_trace_parse_array_end(pi, __FILE__, __LINE__); \
+    }
+#else
+#define TRACE(option, func, obj, depth, where)
+#define TRACE_PARSE_IN(option, func, pi)
+#define TRACE_PARSE_CALL(option, func, pi, obj)
+#define TRACE_PARSE_HASH_END(option, pi)
+#define TRACE_PARSE_ARRAY_END(option, pi)
+#endif
+
 #endif /* OJ_TRACE_H */

data/ext/oj/usual.c

@@ -1,9 +1,11 @@
 // Copyright (c) 2021, Peter Ohler, All rights reserved.
 
+#include "usual.h"
+
 #include "cache.h"
+#include "mem.h"
 #include "oj.h"
 #include "parser.h"
-#include "usual.h"
 
 // The Usual delegate builds Ruby objects during parsing. It makes use of
 // three stacks. The first is the value stack. This is where parsed values are
@@ -34,7 +36,7 @@ static ID ltlt_id = 0;
 static ID hset_id = 0;
 
 static char *str_dup(const char *s, size_t len) {
-    char *d = ALLOC_N(char, len + 1);
+    char *d = OJ_R_ALLOC_N(char, len + 1);
 
     memcpy(d, s, len);
     d[len] = '\0';
@@ -54,7 +56,7 @@ static VALUE form_attr(const char *str, size_t len) {
     char buf[256];
 
     if (sizeof(buf) - 2 <= len) {
-        char *b = ALLOC_N(char, len + 2);
+        char *b = OJ_R_ALLOC_N(char, len + 2);
         ID    id;
 
         *b = '@';
@@ -62,7 +64,7 @@ static VALUE form_attr(const char *str, size_t len) {
         b[len + 1] = '\0';
 
         id = rb_intern3(buf, len + 1, oj_utf8_encoding);
-        xfree(b);
+        OJ_R_FREE(b);
         return id;
     }
     *buf = '@';
@@ -89,8 +91,8 @@ static VALUE resolve_classname(VALUE mod, const char *classname, bool auto_defin
 static VALUE resolve_classpath(const char *name, size_t len, bool auto_define) {
     char        class_name[1024];
     VALUE       clas;
-    char *      end = class_name + sizeof(class_name) - 1;
-    char *      s;
+    char       *end = class_name + sizeof(class_name) - 1;
+    char       *s;
     const char *n = name;
 
     clas = rb_cObject;
@@ -130,7 +132,7 @@ static void assure_cstack(Usual d) {
         long   pos = d->ctail - d->chead;
 
         cap *= 2;
-        REALLOC_N(d->chead, struct _col, cap);
+        OJ_R_REALLOC_N(d->chead, struct _col, cap);
         d->ctail = d->chead + pos;
         d->cend  = d->chead + cap;
     }
@@ -144,7 +146,7 @@ static void push(ojParser p, VALUE v) {
         long   pos = d->vtail - d->vhead;
 
         cap *= 2;
-        REALLOC_N(d->vhead, VALUE, cap);
+        OJ_R_REALLOC_N(d->vhead, VALUE, cap);
         d->vtail = d->vhead + pos;
         d->vend  = d->vhead + cap;
     }
@@ -185,7 +187,7 @@ static ID get_attr_id(ojParser p, Key kp) {
 }
 
 static void push_key(ojParser p) {
-    Usual    d    = (Usual)p->ctx;
+    Usual       d    = (Usual)p->ctx;
     size_t      klen = buf_len(&p->key);
     const char *key  = buf_str(&p->key);
 
@@ -194,7 +196,7 @@ static void push_key(ojParser p) {
         long   pos = d->ktail - d->khead;
 
         cap *= 2;
-        REALLOC_N(d->khead, union _key, cap);
+        OJ_R_REALLOC_N(d->khead, union _key, cap);
         d->ktail = d->khead + pos;
         d->kend  = d->khead + cap;
     }
@@ -216,7 +218,7 @@ static void push2(ojParser p, VALUE v) {
         long   pos = d->vtail - d->vhead;
 
         cap *= 2;
-        REALLOC_N(d->vhead, VALUE, cap);
+        OJ_R_REALLOC_N(d->vhead, VALUE, cap);
         d->vtail = d->vhead + pos;
         d->vend  = d->vhead + cap;
     }
@@ -269,53 +271,49 @@ static void open_array_key(ojParser p) {
 }
 
 static void close_object(ojParser p) {
-    VALUE *  vp;
-    Usual d = (Usual)p->ctx;
+    VALUE *vp;
+    Usual  d = (Usual)p->ctx;
 
     d->ctail--;
 
     Col            c    = d->ctail;
     Key            kp   = d->khead + c->ki;
-    VALUE *        head = d->vhead + c->vi + 1;
+    VALUE         *head = d->vhead + c->vi + 1;
     volatile VALUE obj  = rb_hash_new();
 
-#if HAVE_RB_HASH_BULK_INSERT
     for (vp = head; kp < d->ktail; kp++, vp += 2) {
         *vp = d->get_key(p, kp);
         if (sizeof(kp->buf) <= (size_t)kp->len) {
-            xfree(kp->key);
+            OJ_R_FREE(kp->key);
         }
     }
     rb_hash_bulk_insert(d->vtail - head, head, obj);
-#else
-    for (vp = head; kp < d->ktail; kp++, vp += 2) {
-        rb_hash_aset(obj, d->get_key(p, kp), *(vp + 1));
-        if (sizeof(kp->buf) <= (size_t)kp->len) {
-            xfree(kp->key);
-        }
-    }
-#endif
     d->ktail = d->khead + c->ki;
+
     d->vtail = head;
     head--;
     *head = obj;
+    if (1 == d->vtail - d->vhead && rb_block_given_p()) {
+        d->vtail = d->vhead;
+        rb_yield(obj);
+    }
 }
 
 static void close_object_class(ojParser p) {
-    VALUE *  vp;
-    Usual d = (Usual)p->ctx;
+    VALUE *vp;
+    Usual  d = (Usual)p->ctx;
 
     d->ctail--;
 
     Col            c    = d->ctail;
     Key            kp   = d->khead + c->ki;
-    VALUE *        head = d->vhead + c->vi + 1;
+    VALUE         *head = d->vhead + c->vi + 1;
     volatile VALUE obj  = rb_class_new_instance(0, NULL, d->hash_class);
 
     for (vp = head; kp < d->ktail; kp++, vp += 2) {
         rb_funcall(obj, hset_id, 2, d->get_key(p, kp), *(vp + 1));
         if (sizeof(kp->buf) <= (size_t)kp->len) {
-            xfree(kp->key);
+            OJ_R_FREE(kp->key);
         }
     }
     d->ktail = d->khead + c->ki;
@@ -325,42 +323,33 @@ static void close_object_class(ojParser p) {
 }
 
 static void close_object_create(ojParser p) {
-    VALUE *  vp;
-    Usual d = (Usual)p->ctx;
+    VALUE *vp;
+    Usual  d = (Usual)p->ctx;
 
     d->ctail--;
 
     Col            c    = d->ctail;
     Key            kp   = d->khead + c->ki;
-    VALUE *        head = d->vhead + c->vi;
+    VALUE         *head = d->vhead + c->vi;
     volatile VALUE obj;
 
     if (Qundef == *head) {
         head++;
         if (Qnil == d->hash_class) {
             obj = rb_hash_new();
-#if HAVE_RB_HASH_BULK_INSERT
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 *vp = d->get_key(p, kp);
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
+                    OJ_R_FREE(kp->key);
                 }
             }
             rb_hash_bulk_insert(d->vtail - head, head, obj);
-#else
-            for (vp = head; kp < d->ktail; kp++, vp += 2) {
-                rb_hash_aset(obj, d->get_key(p, kp), *(vp + 1));
-                if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
-                }
-            }
-#endif
         } else {
             obj = rb_class_new_instance(0, NULL, d->hash_class);
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 rb_funcall(obj, hset_id, 2, d->get_key(p, kp), *(vp + 1));
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
+                    OJ_R_FREE(kp->key);
                 }
             }
         }
@@ -371,29 +360,20 @@ static void close_object_create(ojParser p) {
         if (!d->ignore_json_create && rb_respond_to(clas, oj_json_create_id)) {
             volatile VALUE arg = rb_hash_new();
 
-#if HAVE_RB_HASH_BULK_INSERT
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 *vp = d->get_key(p, kp);
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
+                    OJ_R_FREE(kp->key);
                 }
             }
             rb_hash_bulk_insert(d->vtail - head, head, arg);
-#else
-            for (vp = head; kp < d->ktail; kp++, vp += 2) {
-                rb_hash_aset(arg, d->get_key(p, kp), *(vp + 1));
-                if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
-                }
-            }
-#endif
             obj = rb_funcall(clas, oj_json_create_id, 1, arg);
         } else {
             obj = rb_class_new_instance(0, NULL, clas);
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 rb_ivar_set(obj, get_attr_id(p, kp), *(vp + 1));
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    xfree(kp->key);
+                    OJ_R_FREE(kp->key);
                 }
             }
         }
@@ -408,7 +388,7 @@ static void close_array(ojParser p) {
     Usual d = (Usual)p->ctx;
 
     d->ctail--;
-    VALUE *        head = d->vhead + d->ctail->vi + 1;
+    VALUE         *head = d->vhead + d->ctail->vi + 1;
     volatile VALUE a    = rb_ary_new_from_values(d->vtail - head, head);
 
     d->vtail = head;
@@ -417,11 +397,11 @@ static void close_array(ojParser p) {
 }
 
 static void close_array_class(ojParser p) {
-    VALUE *  vp;
-    Usual d = (Usual)p->ctx;
+    VALUE *vp;
+    Usual  d = (Usual)p->ctx;
 
     d->ctail--;
-    VALUE *        head = d->vhead + d->ctail->vi + 1;
+    VALUE         *head = d->vhead + d->ctail->vi + 1;
     volatile VALUE a    = rb_class_new_instance(0, NULL, d->array_class);
 
     for (vp = head; vp < d->vtail; vp++) {
@@ -531,9 +511,9 @@ static void add_big_as_ruby_key(ojParser p) {
 }
 
 static void add_str(ojParser p) {
-    Usual       d = (Usual)p->ctx;
+    Usual          d = (Usual)p->ctx;
     volatile VALUE rstr;
-    const char *   str = buf_str(&p->buf);
+    const char    *str = buf_str(&p->buf);
     size_t         len = buf_len(&p->buf);
 
     if (len < d->cache_str) {
@@ -545,9 +525,9 @@ static void add_str(ojParser p) {
 }
 
 static void add_str_key(ojParser p) {
-    Usual       d = (Usual)p->ctx;
+    Usual          d = (Usual)p->ctx;
     volatile VALUE rstr;
-    const char *   str = buf_str(&p->buf);
+    const char    *str = buf_str(&p->buf);
     size_t         len = buf_len(&p->buf);
 
     if (len < d->cache_str) {
@@ -560,11 +540,11 @@ static void add_str_key(ojParser p) {
 }
 
 static void add_str_key_create(ojParser p) {
-    Usual       d = (Usual)p->ctx;
+    Usual          d = (Usual)p->ctx;
     volatile VALUE rstr;
-    const char *   str  = buf_str(&p->buf);
+    const char    *str  = buf_str(&p->buf);
     size_t         len  = buf_len(&p->buf);
-    const char *   key  = buf_str(&p->key);
+    const char    *key  = buf_str(&p->key);
     size_t         klen = buf_len(&p->key);
 
     if (klen == (size_t)d->create_id_len && 0 == strncmp(d->create_id, key, klen)) {
@@ -597,7 +577,21 @@ static VALUE result(ojParser p) {
     Usual d = (Usual)p->ctx;
 
     if (d->vhead < d->vtail) {
-        return *d->vhead;
+        long            cnt = d->vtail - d->vhead;
+        volatile VALUE  ary;
+        volatile VALUE *vp;
+
+        if (1 == cnt) {
+            return *d->vhead;
+        }
+        ary = rb_ary_new();
+        for (vp = d->vhead; vp < d->vtail; vp++) {
+            rb_ary_push(ary, *vp);
+        }
+        return ary;
+    }
+    if (d->raise_on_empty) {
+        rb_raise(oj_parse_error_class, "empty string");
     }
     return Qnil;
 }
@@ -621,11 +615,11 @@ static void dfree(ojParser p) {
     if (NULL != d->class_cache) {
         cache_free(d->class_cache);
     }
-    xfree(d->vhead);
-    xfree(d->chead);
-    xfree(d->khead);
-    xfree(d->create_id);
-    xfree(p->ctx);
+    OJ_R_FREE(d->vhead);
+    OJ_R_FREE(d->chead);
+    OJ_R_FREE(d->khead);
+    OJ_R_FREE(d->create_id);
+    OJ_R_FREE(p->ctx);
     p->ctx = NULL;
 }
 
@@ -633,8 +627,8 @@ static void mark(ojParser p) {
     if (NULL == p || NULL == p->ctx) {
         return;
     }
-    Usual d = (Usual)p->ctx;
-    VALUE *  vp;
+    Usual  d = (Usual)p->ctx;
+    VALUE *vp;
 
     if (NULL == d) {
         return;
@@ -728,7 +722,7 @@ static VALUE opt_cache_strings(ojParser p, VALUE value) {
 
 static VALUE opt_cache_strings_set(ojParser p, VALUE value) {
     Usual d     = (Usual)p->ctx;
-    int      limit = NUM2INT(value);
+    int   limit = NUM2INT(value);
 
     if (CACHE_MAX_KEY < limit) {
         limit = CACHE_MAX_KEY;
@@ -748,7 +742,7 @@ static VALUE opt_cache_expunge(ojParser p, VALUE value) {
 
 static VALUE opt_cache_expunge_set(ojParser p, VALUE value) {
     Usual d    = (Usual)p->ctx;
-    int      rate = NUM2INT(value);
+    int   rate = NUM2INT(value);
 
     if (rate < 0) {
         rate = 0;
@@ -772,19 +766,19 @@ static VALUE opt_capacity(ojParser p, VALUE value) {
 
 static VALUE opt_capacity_set(ojParser p, VALUE value) {
     Usual d   = (Usual)p->ctx;
-    long     cap = NUM2LONG(value);
+    long  cap = NUM2LONG(value);
 
     if (d->vend - d->vhead < cap) {
         long pos = d->vtail - d->vhead;
 
-        REALLOC_N(d->vhead, VALUE, cap);
+        OJ_R_REALLOC_N(d->vhead, VALUE, cap);
         d->vtail = d->vhead + pos;
         d->vend  = d->vhead + cap;
     }
     if (d->kend - d->khead < cap) {
         long pos = d->ktail - d->khead;
 
-        REALLOC_N(d->khead, union _key, cap);
+        OJ_R_REALLOC_N(d->khead, union _key, cap);
         d->ktail = d->khead + pos;
         d->kend  = d->khead + cap;
     }
@@ -840,8 +834,8 @@ static VALUE opt_create_id_set(ojParser p, VALUE value) {
         rb_check_type(value, T_STRING);
         size_t len = RSTRING_LEN(value);
 
-        if (1 << sizeof(d->create_id_len) <= len) {
-            rb_raise(rb_eArgError, "The create_id values is limited to %d bytes.", 1 << sizeof(d->create_id_len));
+        if (1 << (8 * sizeof(d->create_id_len)) <= len) {
+            rb_raise(rb_eArgError, "The create_id values is limited to %d bytes.", 1 << (8 * sizeof(d->create_id_len)));
         }
         d->create_id_len                  = (uint8_t)len;
         d->create_id                      = str_dup(RSTRING_PTR(value), len);
@@ -870,7 +864,7 @@ static VALUE opt_decimal(ojParser p, VALUE value) {
 }
 
 static VALUE opt_decimal_set(ojParser p, VALUE value) {
-    const char *   mode;
+    const char    *mode;
     volatile VALUE s;
 
     switch (rb_type(value)) {
@@ -986,8 +980,8 @@ static VALUE opt_missing_class(ojParser p, VALUE value) {
 }
 
 static VALUE opt_missing_class_set(ojParser p, VALUE value) {
-    Usual       d = (Usual)p->ctx;
-    const char *   mode;
+    Usual          d = (Usual)p->ctx;
+    const char    *mode;
     volatile VALUE s;
 
     switch (rb_type(value)) {
@@ -1064,36 +1058,52 @@ static VALUE opt_symbol_keys_set(ojParser p, VALUE value) {
     return (NULL != d->sym_cache) ? Qtrue : Qfalse;
 }
 
+static VALUE opt_raise_on_empty(ojParser p, VALUE value) {
+    Usual d = (Usual)p->ctx;
+
+    return d->raise_on_empty ? Qtrue : Qfalse;
+}
+
+static VALUE opt_raise_on_empty_set(ojParser p, VALUE value) {
+    Usual d = (Usual)p->ctx;
+
+    d->raise_on_empty = (Qtrue == value);
+
+    return d->raise_on_empty ? Qtrue : Qfalse;
+}
+
 static VALUE option(ojParser p, const char *key, VALUE value) {
     struct opt *op;
     struct opt  opts[] = {
-         {.name = "array_class", .func = opt_array_class},
-         {.name = "array_class=", .func = opt_array_class_set},
-         {.name = "cache_keys", .func = opt_cache_keys},
-         {.name = "cache_keys=", .func = opt_cache_keys_set},
-         {.name = "cache_strings", .func = opt_cache_strings},
-         {.name = "cache_strings=", .func = opt_cache_strings_set},
-         {.name = "cache_expunge", .func = opt_cache_expunge},
-         {.name = "cache_expunge=", .func = opt_cache_expunge_set},
-         {.name = "capacity", .func = opt_capacity},
-         {.name = "capacity=", .func = opt_capacity_set},
-         {.name = "class_cache", .func = opt_class_cache},
-         {.name = "class_cache=", .func = opt_class_cache_set},
-         {.name = "create_id", .func = opt_create_id},
-         {.name = "create_id=", .func = opt_create_id_set},
-         {.name = "decimal", .func = opt_decimal},
-         {.name = "decimal=", .func = opt_decimal_set},
-         {.name = "hash_class", .func = opt_hash_class},
-         {.name = "hash_class=", .func = opt_hash_class_set},
-         {.name = "ignore_json_create", .func = opt_ignore_json_create},
-         {.name = "ignore_json_create=", .func = opt_ignore_json_create_set},
-         {.name = "missing_class", .func = opt_missing_class},
-         {.name = "missing_class=", .func = opt_missing_class_set},
-         {.name = "omit_null", .func = opt_omit_null},
-         {.name = "omit_null=", .func = opt_omit_null_set},
-         {.name = "symbol_keys", .func = opt_symbol_keys},
-         {.name = "symbol_keys=", .func = opt_symbol_keys_set},
-         {.name = NULL},
+        {.name = "array_class", .func = opt_array_class},
+        {.name = "array_class=", .func = opt_array_class_set},
+        {.name = "cache_keys", .func = opt_cache_keys},
+        {.name = "cache_keys=", .func = opt_cache_keys_set},
+        {.name = "cache_strings", .func = opt_cache_strings},
+        {.name = "cache_strings=", .func = opt_cache_strings_set},
+        {.name = "cache_expunge", .func = opt_cache_expunge},
+        {.name = "cache_expunge=", .func = opt_cache_expunge_set},
+        {.name = "capacity", .func = opt_capacity},
+        {.name = "capacity=", .func = opt_capacity_set},
+        {.name = "class_cache", .func = opt_class_cache},
+        {.name = "class_cache=", .func = opt_class_cache_set},
+        {.name = "create_id", .func = opt_create_id},
+        {.name = "create_id=", .func = opt_create_id_set},
+        {.name = "decimal", .func = opt_decimal},
+        {.name = "decimal=", .func = opt_decimal_set},
+        {.name = "hash_class", .func = opt_hash_class},
+        {.name = "hash_class=", .func = opt_hash_class_set},
+        {.name = "ignore_json_create", .func = opt_ignore_json_create},
+        {.name = "ignore_json_create=", .func = opt_ignore_json_create_set},
+        {.name = "missing_class", .func = opt_missing_class},
+        {.name = "missing_class=", .func = opt_missing_class_set},
+        {.name = "omit_null", .func = opt_omit_null},
+        {.name = "omit_null=", .func = opt_omit_null_set},
+        {.name = "symbol_keys", .func = opt_symbol_keys},
+        {.name = "symbol_keys=", .func = opt_symbol_keys_set},
+        {.name = "raise_on_empty", .func = opt_raise_on_empty},
+        {.name = "raise_on_empty=", .func = opt_raise_on_empty_set},
+        {.name = NULL},
     };
 
     for (op = opts; NULL != op->name; op++) {
@@ -1109,24 +1119,25 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
 ///// the set up //////////////////////////////////////////////////////////////
 
 void oj_init_usual(ojParser p, Usual d) {
-    int      cap = 4096;
+    int cap = 4096;
 
-    d->vhead = ALLOC_N(VALUE, cap);
+    d->vhead = OJ_R_ALLOC_N(VALUE, cap);
     d->vend  = d->vhead + cap;
     d->vtail = d->vhead;
 
-    d->khead = ALLOC_N(union _key, cap);
+    d->khead = OJ_R_ALLOC_N(union _key, cap);
     d->kend  = d->khead + cap;
     d->ktail = d->khead;
 
     cap      = 256;
-    d->chead = ALLOC_N(struct _col, cap);
+    d->chead = OJ_R_ALLOC_N(struct _col, cap);
     d->cend  = d->chead + cap;
     d->ctail = d->chead;
 
     d->get_key            = cache_key;
     d->cache_keys         = true;
     d->ignore_json_create = false;
+    d->raise_on_empty     = false;
     d->cache_str          = 6;
     d->array_class        = Qnil;
     d->hash_class         = Qnil;
@@ -1201,7 +1212,7 @@ void oj_init_usual(ojParser p, Usual d) {
 }
 
 void oj_set_parser_usual(ojParser p) {
-    Usual d = ALLOC(struct _usual);
+    Usual d = OJ_R_ALLOC(struct _usual);
 
     oj_init_usual(p, d);
 }

data/ext/oj/usual.h

@@ -13,7 +13,7 @@ struct _ojParser;
 typedef struct _col {
     long vi;  // value stack index
     long ki;  // key stack index if an hash else -1 for an array
-} * Col;
+} *Col;
 
 typedef union _key {
     struct {
@@ -22,9 +22,9 @@ typedef union _key {
     };
     struct {
         int16_t xlen;  // should be the same as len
-        char *  key;
+        char   *key;
     };
-} * Key;
+} *Key;
 
 #define MISS_AUTO 'A'
 #define MISS_RAISE 'R'
@@ -43,7 +43,7 @@ typedef struct _usual {
     Key ktail;
     Key kend;
 
-    VALUE (*get_key)(ojParser p, Key kp);
+    VALUE (*get_key)(struct _ojParser *p, Key kp);
     struct _cache *key_cache;  // same as str_cache or sym_cache
     struct _cache *str_cache;
     struct _cache *sym_cache;
@@ -53,14 +53,15 @@ typedef struct _usual {
     VALUE array_class;
     VALUE hash_class;
 
-    char *  create_id;
+    char   *create_id;
     uint8_t create_id_len;
     uint8_t cache_str;
     uint8_t cache_xrate;
     uint8_t miss_class;
     bool    cache_keys;
     bool    ignore_json_create;
-} * Usual;
+    bool    raise_on_empty;
+} *Usual;
 
 // Initialize the parser with the usual delegate. If the usual delegate is
 // wrapped then this function is called first and then the parser functions

data/ext/oj/util.h

@@ -13,7 +13,7 @@ typedef struct _timeInfo {
     int day;
     int mon;
     int year;
-} * TimeInfo;
+}* TimeInfo;
 
 extern void sec_as_time(int64_t secs, TimeInfo ti);
 

data/ext/oj/val_stack.c

@@ -8,7 +8,7 @@
 #include "odd.h"
 #include "oj.h"
 
-static void mark(void *ptr) {
+static void stack_mark(void *ptr) {
     ValStack stack = (ValStack)ptr;
     Val      v;
 
@@ -46,6 +46,17 @@ static void mark(void *ptr) {
 #endif
 }
 
+static const rb_data_type_t oj_stack_type = {
+    "Oj/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 VALUE
 oj_stack_init(ValStack stack) {
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -70,7 +81,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clen      = 0;
     stack->head->next      = NEXT_NONE;
 
-    return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
+    return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);
 }
 
 const char *oj_stack_next_string(ValNext n) {