oj 3.13.23 → 3.14.2

data/ext/oj/parse.c

@@ -10,12 +10,17 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "mem.h"
 #include "buf.h"
 #include "encode.h"
 #include "oj.h"
 #include "rxclass.h"
 #include "val_stack.h"
 
+#ifdef OJ_USE_SSE4_2
+#include <nmmintrin.h>
+#endif
+
 // Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
 #define OJ_INFINITY (1.0 / 0.0)
 
@@ -83,7 +88,7 @@ static void add_value(ParseInfo pi, VALUE rval) {
             pi->hash_set_value(pi, parent, rval);
             if (0 != parent->key && 0 < parent->klen &&
                 (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -232,7 +237,8 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
 
     for (s = pi->cur; '"' != *s;) {
         const char *scanned = scan_func(s, pi->end);
-        if (scanned >= pi->end) {
+        if (scanned >= pi->end || '\0' == *scanned) {
+            //if (scanned >= pi->end) {
             oj_set_error_at(pi,
                             oj_parse_error_class,
                             __FILE__,
@@ -241,7 +247,6 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
             buf_cleanup(&buf);
             return;
         }
-
         buf_append_string(&buf, s, (size_t)(scanned - s));
         s = scanned;
 
@@ -330,7 +335,7 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
         case NEXT_HASH_KEY:
             if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
                 parent->klen = buf_len(&buf);
-                parent->key  = malloc(parent->klen + 1);
+                parent->key  = OJ_MALLOC(parent->klen + 1);
                 memcpy((char *)parent->key, buf.head, parent->klen);
                 *(char *)(parent->key + parent->klen) = '\0';
             } else {
@@ -344,7 +349,7 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
             pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), start);
             if (0 != parent->key && 0 < parent->klen &&
                 (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -414,7 +419,7 @@ static void read_str(ParseInfo pi) {
             pi->hash_set_cstr(pi, parent, str, pi->cur - str, str);
             if (0 != parent->key && 0 < parent->klen &&
                 (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -613,7 +618,7 @@ static void read_num(ParseInfo pi) {
             pi->hash_set_num(pi, parent, &ni);
             if (0 != parent->key && 0 < parent->klen &&
                 (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -867,12 +872,12 @@ oj_num_as_value(NumInfo ni) {
                 buf[ni->len] = '\0';
                 rnum         = rb_cstr_to_inum(buf, 10, 0);
             } else {
-                char *buf = ALLOC_N(char, ni->len + 1);
+                char *buf = OJ_R_ALLOC_N(char, ni->len + 1);
 
                 memcpy(buf, ni->str, ni->len);
                 buf[ni->len] = '\0';
                 rnum         = rb_cstr_to_inum(buf, 10, 0);
-                xfree(buf);
+                OJ_R_FREE(buf);
             }
         } else {
             if (ni->neg) {
@@ -1073,12 +1078,12 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             size_t  len = lseek(fd, 0, SEEK_END);
 
             lseek(fd, 0, SEEK_SET);
-            buf      = ALLOC_N(char, len + 1);
+            buf      = OJ_R_ALLOC_N(char, len + 1);
             pi->json = buf;
             pi->end  = buf + len;
             if (0 >= (cnt = read(fd, (char *)pi->json, len)) || cnt != (ssize_t)len) {
                 if (0 != buf) {
-                    xfree(buf);
+                    OJ_R_FREE(buf);
                 }
                 rb_raise(rb_eIOError, "failed to read from IO Object.");
             }
@@ -1160,9 +1165,9 @@ CLEANUP:
         oj_circ_array_free(pi->circ_array);
     }
     if (0 != buf) {
-        xfree(buf);
+        OJ_R_FREE(buf);
     } else if (free_json) {
-        xfree(json);
+        OJ_R_FREE(json);
     }
     stack_cleanup(&pi->stack);
     if (pi->str_rx.head != oj_default_options.str_rx.head) {

data/ext/oj/parser.c

@@ -1148,7 +1148,7 @@ static void parser_free(void *ptr) {
     if (NULL != p->free) {
         p->free(p);
     }
-    xfree(ptr);
+    OJ_R_FREE(ptr);
 }
 
 static void parser_mark(void *ptr) {
@@ -1205,7 +1205,7 @@ static int opt_cb(VALUE rkey, VALUE value, VALUE ptr) {
  * Oj::Parser.new(:usual, cache_keys: true).
  */
 static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
-    ojParser p = ALLOC(struct _ojParser);
+    ojParser p = OJ_R_ALLOC(struct _ojParser);
 
 #if HAVE_RB_EXT_RACTOR_SAFE
     // This doesn't seem to do anything.
@@ -1263,8 +1263,8 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
 // from this function. A delegate must be added before the parser can be
 // used. Optionally oj_parser_set_options can be called if the options are not
 // set directly.
-VALUE oj_parser_new() {
-    ojParser p = ALLOC(struct _ojParser);
+VALUE oj_parser_new(void) {
+    ojParser p = OJ_R_ALLOC(struct _ojParser);
 
 #if HAVE_RB_EXT_RACTOR_SAFE
     // This doesn't seem to do anything.
@@ -1499,7 +1499,7 @@ static VALUE usual_parser = Qundef;
  */
 static VALUE parser_usual(VALUE self) {
     if (Qundef == usual_parser) {
-        ojParser p = ALLOC(struct _ojParser);
+        ojParser p = OJ_R_ALLOC(struct _ojParser);
 
         memset(p, 0, sizeof(struct _ojParser));
         buf_init(&p->key);
@@ -1522,7 +1522,7 @@ static VALUE saj_parser = Qundef;
  */
 static VALUE parser_saj(VALUE self) {
     if (Qundef == saj_parser) {
-        ojParser p = ALLOC(struct _ojParser);
+        ojParser p = OJ_R_ALLOC(struct _ojParser);
 
         memset(p, 0, sizeof(struct _ojParser));
         buf_init(&p->key);
@@ -1544,7 +1544,7 @@ static VALUE validate_parser = Qundef;
  */
 static VALUE parser_validate(VALUE self) {
     if (Qundef == validate_parser) {
-        ojParser p = ALLOC(struct _ojParser);
+        ojParser p = OJ_R_ALLOC(struct _ojParser);
 
         memset(p, 0, sizeof(struct _ojParser));
         buf_init(&p->key);

data/ext/oj/rails.c

@@ -3,6 +3,7 @@
 
 #include "rails.h"
 
+#include "mem.h"
 #include "code.h"
 #include "encode.h"
 #include "trace.h"
@@ -76,7 +77,7 @@ static ROptTable copy_opts(ROptTable src, ROptTable dest) {
     if (NULL == src->table) {
         dest->table = NULL;
     } else {
-        dest->table = ALLOC_N(struct _rOpt, dest->alen);
+        dest->table = OJ_R_ALLOC_N(struct _rOpt, dest->alen);
         memcpy(dest->table, src->table, sizeof(struct _rOpt) * dest->alen);
     }
     return NULL;
@@ -198,7 +199,7 @@ static void dump_enumerable(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
     const char *   str  = RSTRING_PTR(rstr);
 
     if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
@@ -345,7 +346,7 @@ static void dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_to_s(VALUE obj, int depth, Out out, bool as_ok) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
 
     oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
@@ -373,11 +374,11 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
     int            cnt = (int)RARRAY_LEN(rcols);
 
     *ccnt = cnt;
-    cols  = ALLOC_N(struct _strLen, cnt);
+    cols  = OJ_R_ALLOC_N(struct _strLen, cnt);
     for (i = 0, cp = cols; i < cnt; i++, cp++) {
         v = RARRAY_AREF(rcols, i);
         if (T_STRING != rb_type(v)) {
-            v = rb_funcall(v, oj_to_s_id, 0);
+            v = oj_safe_string_convert(v);
         }
         cp->str = StringValuePtr(v);
         cp->len = (int)RSTRING_LEN(v);
@@ -481,7 +482,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
             *out->cur++ = ',';
         }
     }
-    xfree(cols);
+    OJ_R_FREE(cols);
     size = depth * out->indent + 1;
     assure_size(out, size);
     if (out->opts->dump_opts.use) {
@@ -517,9 +518,7 @@ static void dump_as_string(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_as_json(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE ja;
 
-    if (RB_UNLIKELY(Yes == out->opts->trace)) {
-        oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyIn);
-    }
+    TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyIn);
     // Some classes elect to not take an options argument so check the arity
     // of as_json.
     if (0 == rb_obj_method_arity(obj, oj_as_json_id)) {
@@ -527,9 +526,7 @@ static void dump_as_json(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         ja = rb_funcall2(obj, oj_as_json_id, out->argc, out->argv);
     }
-    if (RB_UNLIKELY(Yes == out->opts->trace)) {
-        oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
-    }
+    TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyOut);
 
     out->argc = 0;
     if (ja == obj || !as_ok) {
@@ -587,11 +584,11 @@ static ROpt create_opt(ROptTable rot, VALUE clas) {
     rot->len++;
     if (NULL == rot->table) {
         rot->alen  = 256;
-        rot->table = ALLOC_N(struct _rOpt, rot->alen);
+        rot->table = OJ_R_ALLOC_N(struct _rOpt, rot->alen);
         memset(rot->table, 0, sizeof(struct _rOpt) * rot->alen);
     } else if (rot->alen <= rot->len) {
         rot->alen *= 2;
-        REALLOC_N(rot->table, struct _rOpt, rot->alen);
+        OJ_R_REALLOC_N(rot->table, struct _rOpt, rot->alen);
         memset(rot->table + olen, 0, sizeof(struct _rOpt) * olen);
     }
     if (0 == olen) {
@@ -644,9 +641,9 @@ static void encoder_free(void *ptr) {
         Encoder e = (Encoder)ptr;
 
         if (NULL != e->ropts.table) {
-            xfree(e->ropts.table);
+            OJ_R_FREE(e->ropts.table);
         }
-        xfree(ptr);
+        OJ_R_FREE(ptr);
     }
 }
 
@@ -667,7 +664,7 @@ static void encoder_mark(void *ptr) {
  * - *options* [_Hash_] formatting options
  */
 static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
-    Encoder e = ALLOC(struct _encoder);
+    Encoder e = OJ_R_ALLOC(struct _encoder);
 
     e->opts = oj_default_options;
     e->arg  = Qnil;
@@ -1208,7 +1205,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         } else if (oj_rails_float_opt) {
             cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, "%0.16g");
         } else {
-            volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+            volatile VALUE rstr = oj_safe_string_convert(obj);
 
             strcpy(buf, RSTRING_PTR(rstr));
             cnt = (int)RSTRING_LEN(rstr);
@@ -1301,7 +1298,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         return ST_CONTINUE;
     }
     if (rtype != T_STRING && rtype != T_SYMBOL) {
-        key   = rb_funcall(key, oj_to_s_id, 0);
+        key   = oj_safe_string_convert(key);
         rtype = rb_type(key);
     }
     if (!out->opts->dump_opts.use) {
@@ -1464,9 +1461,7 @@ static DumpFunc rails_funcs[] = {
 static void dump_rails_val(VALUE obj, int depth, Out out, bool as_ok) {
     int type = rb_type(obj);
 
-    if (RB_UNLIKELY(Yes == out->opts->trace)) {
-        oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
-    }
+    TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
     if (MAX_DEPTH < depth) {
         rb_raise(rb_eNoMemError, "Too deeply nested.\n");
     }
@@ -1475,16 +1470,12 @@ static void dump_rails_val(VALUE obj, int depth, Out out, bool as_ok) {
 
         if (NULL != f) {
             f(obj, depth, out, as_ok);
-            if (RB_UNLIKELY(Yes == out->opts->trace)) {
-                oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
-            }
+            TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
             return;
         }
     }
     oj_dump_nil(Qnil, depth, out, false);
-    if (RB_UNLIKELY(Yes == out->opts->trace)) {
-        oj_trace("dump", Qnil, __FILE__, __LINE__, depth, TraceOut);
-    }
+    TRACE(out->opts->trace, "dump", Qnil, depth, TraceOut);
 }
 
 void oj_dump_rails_val(VALUE obj, int depth, Out out) {

data/ext/oj/reader.c

@@ -14,6 +14,7 @@
 #include <time.h>
 #include <unistd.h>
 
+#include "mem.h"
 #include "oj.h"
 #include "reader.h"
 #include "ruby.h"
@@ -75,7 +76,7 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
         reader->read_func = read_from_io;
         reader->io        = io;
     } else if (to_s) {
-        volatile VALUE rstr = rb_funcall(io, oj_to_s_id, 0);
+        volatile VALUE rstr = oj_safe_string_convert(io);
 
         reader->read_func = 0;
         reader->in_str    = StringValuePtr(rstr);
@@ -107,10 +108,10 @@ int oj_reader_read(Reader reader) {
             size_t      size = reader->end - reader->head + BUF_PAD;
 
             if (reader->head == reader->base) {
-                reader->head = ALLOC_N(char, size * 2);
+                reader->head = OJ_R_ALLOC_N(char, size * 2);
                 memcpy((char *)reader->head, old, size);
             } else {
-                REALLOC_N(reader->head, char, size * 2);
+                OJ_R_REALLOC_N(reader->head, char, size * 2);
             }
             reader->free_head = 1;
             reader->end       = reader->head + size * 2 - BUF_PAD;

data/ext/oj/reader.h

@@ -4,6 +4,8 @@
 #ifndef OJ_READER_H
 #define OJ_READER_H
 
+#include "mem.h"
+
 typedef struct _reader {
     char  base[0x00001000];
     char *head;
@@ -114,7 +116,7 @@ static inline int reader_expect(Reader reader, const char *s) {
 
 static inline void reader_cleanup(Reader reader) {
     if (reader->free_head && 0 != reader->head) {
-        xfree((char *)reader->head);
+        OJ_R_FREE((char *)reader->head);
         reader->head      = 0;
         reader->free_head = 0;
     }

data/ext/oj/rxclass.c

@@ -10,6 +10,7 @@
 #include <regex.h>
 #endif
 
+#include "mem.h"
 #include "rxclass.h"
 
 typedef struct _rxC {
@@ -37,13 +38,13 @@ void oj_rxclass_cleanup(RxClass rc) {
         if (Qnil == rxc->rrx) {
             regfree(&rxc->rx);
         }
-        xfree(rxc);
+        OJ_R_FREE(rxc);
 #endif
     }
 }
 
 void oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
-    RxC rxc = ALLOC_N(struct _rxC, 1);
+    RxC rxc = OJ_R_ALLOC_N(struct _rxC, 1);
 
     memset(rxc, 0, sizeof(struct _rxC));
     rxc->rrx  = rx;
@@ -70,7 +71,7 @@ int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
                  (unsigned long)sizeof(rxc->src));
         return EINVAL;
     }
-    rxc       = ALLOC_N(struct _rxC, 1);
+    rxc       = OJ_R_ALLOC_N(struct _rxC, 1);
     rxc->next = 0;
     rxc->clas = clas;
 
@@ -80,7 +81,7 @@ int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
     rxc->rrx = Qnil;
     if (0 != (err = regcomp(&rxc->rx, expr, flags))) {
         regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
-        free(rxc);
+        OJ_FREE(rxc);
         return err;
     }
 #endif

data/ext/oj/saj.c

@@ -14,6 +14,7 @@
 // Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
 #define OJ_INFINITY (1.0 / 0.0)
 
+#include "mem.h"
 #include "encode.h"
 #include "oj.h"
 
@@ -631,7 +632,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
     if (rb_type(input) == T_STRING) {
         // the json string gets modified so make a copy of it
         len  = RSTRING_LEN(input) + 1;
-        json = ALLOC_N(char, len);
+        json = OJ_R_ALLOC_N(char, len);
         strcpy(json, StringValuePtr(input));
     } else {
         VALUE          clas = rb_obj_class(input);
@@ -640,7 +641,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
         if (oj_stringio_class == clas) {
             s    = rb_funcall2(input, oj_string_id, 0, 0);
             len  = RSTRING_LEN(s) + 1;
-            json = ALLOC_N(char, len);
+            json = OJ_R_ALLOC_N(char, len);
             strcpy(json, rb_string_value_cstr((VALUE *)&s));
 #if !IS_WINDOWS
         } else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
@@ -649,7 +650,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
 
             len = lseek(fd, 0, SEEK_END);
             lseek(fd, 0, SEEK_SET);
-            json = ALLOC_N(char, len + 1);
+            json = OJ_R_ALLOC_N(char, len + 1);
             if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
                 rb_raise(rb_eIOError, "failed to read from IO Object.");
             }
@@ -658,14 +659,14 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
         } else if (rb_respond_to(input, oj_read_id)) {
             s    = rb_funcall2(input, oj_read_id, 0, 0);
             len  = RSTRING_LEN(s) + 1;
-            json = ALLOC_N(char, len);
+            json = OJ_R_ALLOC_N(char, len);
             strcpy(json, rb_string_value_cstr((VALUE *)&s));
         } else {
             rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
         }
     }
     saj_parse(*argv, json);
-    xfree(json);
+    OJ_R_FREE(json);
 
     return Qnil;
 }

data/ext/oj/saj2.c

@@ -1,5 +1,6 @@
 // Copyright (c) 2021, Peter Ohler, All rights reserved.
 
+#include "mem.h"
 #include "cache.h"
 #include "oj.h"
 #include "parser.h"
@@ -24,7 +25,7 @@ static void push_key(Saj d, VALUE key) {
         size_t off = d->tail - d->keys;
 
         d->klen += d->klen / 2;
-        REALLOC_N(d->keys, VALUE, d->klen);
+        OJ_R_REALLOC_N(d->keys, VALUE, d->klen);
         d->tail = d->keys + off;
     }
     *d->tail = key;
@@ -546,10 +547,10 @@ static void dfree(ojParser p) {
     Saj d = (Saj)p->ctx;
 
     if (NULL != d->keys) {
-        xfree(d->keys);
+        OJ_R_FREE(d->keys);
     }
     cache_free(d->str_cache);
-    xfree(p->ctx);
+    OJ_R_FREE(p->ctx);
 }
 
 static void mark(ojParser p) {
@@ -576,9 +577,13 @@ static VALUE form_str(const char *str, size_t len) {
 
 void oj_init_saj(ojParser p, Saj d) {
     d->klen      = 256;
-    d->keys      = ALLOC_N(VALUE, d->klen);
+    d->keys      = OJ_R_ALLOC_N(VALUE, d->klen);
     d->tail      = d->keys;
+    d->handler   = Qnil;
     d->str_cache = cache_create(0, form_str, true, false);
+    d->cache_str = 16;
+    d->cache_keys = true;
+    d->thread_safe = false;
 
     p->ctx = (void *)d;
     reset(p);
@@ -590,7 +595,7 @@ void oj_init_saj(ojParser p, Saj d) {
 }
 
 void oj_set_parser_saj(ojParser p) {
-    Saj d = ALLOC(struct _saj);
+    Saj d = OJ_R_ALLOC(struct _saj);
 
     oj_init_saj(p, d);
 }

data/ext/oj/sparse.c

@@ -7,6 +7,7 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "mem.h"
 #include "buf.h"
 #include "encode.h"
 #include "intern.h"  // for oj_strndup()
@@ -71,7 +72,7 @@ static void add_value(ParseInfo pi, VALUE rval) {
         case NEXT_HASH_VALUE:
             pi->hash_set_value(pi, parent, rval);
             if (parent->kalloc) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
             }
             parent->key    = 0;
             parent->kalloc = 0;
@@ -110,7 +111,7 @@ static void add_num_value(ParseInfo pi, NumInfo ni) {
         case NEXT_HASH_VALUE:
             pi->hash_set_num(pi, parent, ni);
             if (parent->kalloc) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
             }
             parent->key    = 0;
             parent->kalloc = 0;
@@ -315,7 +316,7 @@ static void read_escaped_str(ParseInfo pi) {
         case NEXT_HASH_VALUE:
             pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), pi->rd.str);
             if (parent->kalloc) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
             }
             parent->key    = 0;
             parent->kalloc = 0;
@@ -386,7 +387,7 @@ static void read_str(ParseInfo pi) {
         case NEXT_HASH_VALUE:
             pi->hash_set_cstr(pi, parent, pi->rd.str, pi->rd.tail - pi->rd.str - 1, pi->rd.str);
             if (parent->kalloc) {
-                xfree((char *)parent->key);
+                OJ_R_FREE((char *)parent->key);
             }
             parent->key    = 0;
             parent->kalloc = 0;

data/ext/oj/stream_writer.c

@@ -4,6 +4,7 @@
 #include <errno.h>
 #include <ruby.h>
 
+#include "mem.h"
 #include "encode.h"
 
 extern VALUE Oj;
@@ -15,9 +16,9 @@ static void stream_writer_free(void *ptr) {
         return;
     }
     sw = (StreamWriter)ptr;
-    xfree(sw->sw.out.buf);
-    xfree(sw->sw.types);
-    xfree(ptr);
+    OJ_R_FREE(sw->sw.out.buf);
+    OJ_R_FREE(sw->sw.types);
+    OJ_R_FREE(ptr);
 }
 
 static void stream_writer_reset_buf(StreamWriter sw) {
@@ -91,7 +92,7 @@ static VALUE stream_writer_new(int argc, VALUE *argv, VALUE self) {
     } else {
         rb_raise(rb_eArgError, "expected an IO Object.");
     }
-    sw = ALLOC(struct _streamWriter);
+    sw = OJ_R_ALLOC(struct _streamWriter);
     if (2 == argc && T_HASH == rb_type(argv[1])) {
         volatile VALUE v;
         int            buf_size = 0;

data/ext/oj/strict.c

@@ -50,15 +50,11 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
 }
 
 static void hash_end(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void array_end(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_array_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_ARRAY_END(pi->options.trace, pi);
 }
 
 static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
@@ -95,9 +91,7 @@ static VALUE start_hash(ParseInfo pi) {
     if (Qnil != pi->options.hash_class) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
     return rb_hash_new();
 }
 
@@ -137,9 +131,7 @@ static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
 }
 
 static VALUE start_array(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_array", pi);
     return rb_ary_new();
 }