oj 3.14.1 → 3.14.2

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.
@@ -1264,7 +1264,7 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
 // used. Optionally oj_parser_set_options can be called if the options are not
 // set directly.
 VALUE oj_parser_new(void) {
-    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.
@@ -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;
@@ -373,7 +374,7 @@ 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)) {
@@ -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) {
@@ -583,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) {
@@ -640,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);
     }
 }
 
@@ -663,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;

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"
@@ -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,7 +577,7 @@ 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);
@@ -594,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/string_writer.c

@@ -1,6 +1,7 @@
 // Copyright (c) 2012, 2017 Peter Ohler. All rights reserved.
 // Licensed under the MIT License. See LICENSE file in the project root for license details.
 
+#include "mem.h"
 #include "dump.h"
 #include "encode.h"
 
@@ -20,7 +21,7 @@ static void push_type(StrWriter sw, DumpType type) {
     if (sw->types_end <= sw->types + sw->depth + 1) {
         size_t size = (sw->types_end - sw->types) * 2;
 
-        REALLOC_N(sw->types, char, size);
+        OJ_R_REALLOC_N(sw->types, char, size);
         sw->types_end = sw->types + size;
     }
     sw->depth++;
@@ -43,7 +44,7 @@ static void maybe_comma(StrWriter sw) {
 void oj_str_writer_init(StrWriter sw, int buf_size) {
     sw->opts       = oj_default_options;
     sw->depth      = 0;
-    sw->types      = ALLOC_N(char, 256);
+    sw->types      = OJ_R_ALLOC_N(char, 256);
     sw->types_end  = sw->types + 256;
     *sw->types     = '\0';
     sw->keyWritten = 0;
@@ -55,7 +56,7 @@ void oj_str_writer_init(StrWriter sw, int buf_size) {
     }
     // Must be allocated. Using the out.stack_buffer results in double frees
     // and I haven't figured out why yet.
-    sw->out.buf        = ALLOC_N(char, buf_size);
+    sw->out.buf        = OJ_R_ALLOC_N(char, buf_size);
     sw->out.cur        = sw->out.buf;
     sw->out.end        = sw->out.buf + buf_size - BUFFER_EXTRA;
     sw->out.allocated  = true;
@@ -235,8 +236,8 @@ static void str_writer_free(void *ptr) {
 
     oj_out_free(&sw->out);
 
-    xfree(sw->types);
-    xfree(ptr);
+    OJ_R_FREE(sw->types);
+    OJ_R_FREE(ptr);
 }
 
 /* Document-method: new
@@ -256,7 +257,7 @@ static void str_writer_free(void *ptr) {
  * - *options* [_Hash_] formatting options
  */
 static VALUE str_writer_new(int argc, VALUE *argv, VALUE self) {
-    StrWriter sw = ALLOC(struct _strWriter);
+    StrWriter sw = OJ_R_ALLOC(struct _strWriter);
 
     oj_str_writer_init(sw, 0);
     if (1 == argc) {

data/ext/oj/usual.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"
@@ -34,7 +35,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 +55,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 +63,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 = '@';
@@ -130,7 +131,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 +145,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;
     }
@@ -194,7 +195,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 +217,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;
     }
@@ -283,7 +284,7 @@ static void close_object(ojParser p) {
     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);
@@ -291,7 +292,7 @@ static void close_object(ojParser p) {
     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);
+            OJ_R_FREE(kp->key);
         }
     }
 #endif
@@ -315,7 +316,7 @@ static void close_object_class(ojParser p) {
     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;
@@ -343,7 +344,7 @@ static void close_object_create(ojParser p) {
             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);
@@ -351,7 +352,7 @@ static void close_object_create(ojParser p) {
             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);
+                    OJ_R_FREE(kp->key);
                 }
             }
 #endif
@@ -360,7 +361,7 @@ static void close_object_create(ojParser p) {
             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);
                 }
             }
         }
@@ -375,7 +376,7 @@ static void close_object_create(ojParser p) {
             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);
@@ -383,7 +384,7 @@ static void close_object_create(ojParser p) {
             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);
+                    OJ_R_FREE(kp->key);
                 }
             }
 #endif
@@ -393,7 +394,7 @@ static void close_object_create(ojParser p) {
             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);
                 }
             }
         }
@@ -621,11 +622,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;
 }
 
@@ -777,14 +778,14 @@ static VALUE opt_capacity_set(ojParser p, VALUE 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;
     }
@@ -1111,16 +1112,16 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
 void oj_init_usual(ojParser p, Usual d) {
     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;
 
@@ -1201,7 +1202,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/val_stack.h

@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include "mem.h"
 #include "odd.h"
 #include "ruby.h"
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -62,7 +63,7 @@ inline static int stack_empty(ValStack stack) {
 
 inline static void stack_cleanup(ValStack stack) {
     if (stack->base != stack->head) {
-        xfree(stack->head);
+        OJ_R_FREE(stack->head);
         stack->head = NULL;
     }
 }
@@ -76,10 +77,10 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
         // A realloc can trigger a GC so make sure it happens outside the lock
         // but lock before changing pointers.
         if (stack->base == stack->head) {
-            head = ALLOC_N(struct _val, len + STACK_INC);
+            head = OJ_R_ALLOC_N(struct _val, len + STACK_INC);
             memcpy(head, stack->base, sizeof(struct _val) * len);
         } else {
-            REALLOC_N(head, struct _val, len + STACK_INC);
+            OJ_R_REALLOC_N(head, struct _val, len + STACK_INC);
         }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&stack->mutex);

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module.
-  VERSION = '3.14.1'
+  VERSION = '3.14.2'
 end