oj 3.13.23 → 3.16.10

data/ext/oj/fast.c

@@ -11,14 +11,15 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "dump.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.h"
-#include "dump.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_JSON 65536
 #define MAX_STACK 100
-//#define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
+// #define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
 #define BATCH_SIZE 100
 
 // Support for compaction
@@ -32,25 +33,25 @@ typedef struct _batch {
     struct _batch *next;
     int            next_avail;
     struct _leaf   leaves[BATCH_SIZE];
-} * Batch;
+} *Batch;
 
 typedef struct _doc {
     Leaf          data;
-    Leaf *        where;                  // points to current location
+    Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
-    char *        json;
+    char         *json;
     unsigned long size;  // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
-} * Doc;
+} *Doc;
 
 typedef struct _parseInfo {
     char *str;  // buffer being read from
     char *s;    // current position in buffer
     Doc   doc;
     void *stack_min;
-} * ParseInfo;
+} *ParseInfo;
 
 static void  leaf_init(Leaf leaf, int type);
 static Leaf  leaf_new(Doc doc, int type);
@@ -74,7 +75,7 @@ static char *read_quoted_value(ParseInfo pi);
 static void  skip_comment(ParseInfo pi);
 
 static VALUE protect_open_proc(VALUE x);
-static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated);
+static VALUE parse_json(VALUE clas, char *json, bool given);
 static void  each_leaf(Doc doc, VALUE self);
 static int   move_step(Doc doc, const char *path, int loc);
 static Leaf  get_doc_leaf(Doc doc, const char *path);
@@ -113,10 +114,7 @@ inline static char *ulong_fill(char *s, size_t num) {
     char *b = buf + sizeof(buf) - 1;
 
     *b-- = '\0';
-    for (; 0 < num; num /= 10, b--) {
-        *b = (num % 10) + '0';
-    }
-    b++;
+    b    = oj_longlong_to_string((long long)num, false, b);
     if ('\0' == *b) {
         b--;
         *b = '0';
@@ -160,7 +158,7 @@ inline static Leaf leaf_new(Doc doc, int type) {
     Leaf leaf;
 
     if (0 == doc->batches || BATCH_SIZE == doc->batches->next_avail) {
-        Batch b = ALLOC(struct _batch);
+        Batch b = OJ_R_ALLOC(struct _batch);
 
         // Initializes all leaves with a NO_VAL value_type
         memset(b, 0, sizeof(struct _batch));
@@ -195,8 +193,7 @@ static VALUE leaf_value(Doc doc, Leaf leaf) {
         case T_FIXNUM: leaf_fixnum_value(leaf); break;
         case T_FLOAT: leaf_float_value(leaf); break;
         case T_STRING:
-            leaf->value      = rb_str_new2(leaf->str);
-            leaf->value      = oj_encode(leaf->value);
+            leaf->value      = rb_utf8_str_new_cstr(leaf->str);
             leaf->value_type = RUBY_VAL;
             break;
         case T_ARRAY: return leaf_array_value(doc, leaf); break;
@@ -250,7 +247,7 @@ static void skip_comment(ParseInfo pi) {
 #endif
 
 static void leaf_fixnum_value(Leaf leaf) {
-    char *  s   = leaf->str;
+    char   *s   = leaf->str;
     int64_t n   = 0;
     int     neg = 0;
     int     big = 0;
@@ -311,8 +308,7 @@ static VALUE leaf_hash_value(Doc doc, Leaf leaf) {
         volatile VALUE key;
 
         do {
-            key = rb_str_new2(e->key);
-            key = oj_encode(key);
+            key = rb_utf8_str_new_cstr(e->key);
             rb_hash_aset(h, key, leaf_value(doc, e));
             e = e->next;
         } while (e != first);
@@ -356,7 +352,7 @@ static Leaf read_next(ParseInfo pi) {
 
 static Leaf read_obj(ParseInfo pi) {
     Leaf        h = leaf_new(pi->doc, T_HASH);
-    char *      end;
+    char       *end;
     const char *key = 0;
     Leaf        val = 0;
 
@@ -648,10 +644,11 @@ static void doc_free(Doc doc) {
         while (0 != (b = doc->batches)) {
             doc->batches = doc->batches->next;
             if (&doc->batch0 != b) {
-                xfree(b);
+                OJ_R_FREE(b);
             }
         }
-        // xfree(f);
+        OJ_R_FREE(doc->json);
+        OJ_R_FREE(doc);
     }
 }
 
@@ -671,7 +668,6 @@ static void free_doc_cb(void *x) {
     Doc doc = (Doc)x;
 
     if (0 != doc) {
-        xfree(doc->json);
         doc_free(doc);
     }
 }
@@ -749,20 +745,15 @@ static const rb_data_type_t oj_doc_type = {
     0,
 };
 
-static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
+static VALUE parse_json(VALUE clas, char *json, bool given) {
     struct _parseInfo pi;
     volatile VALUE    result = Qnil;
     Doc               doc;
     int               ex = 0;
     volatile VALUE    self;
 
-    // TBD are both needed? is stack allocation ever needed?
+    doc = OJ_R_ALLOC_N(struct _doc, 1);
 
-    if (given) {
-        doc = ALLOCA_N(struct _doc, 1);
-    } else {
-        doc = ALLOC(struct _doc);
-    }
     // skip UTF-8 BOM if present
     if (0xEF == (uint8_t)*json && 0xBB == (uint8_t)json[1] && 0xBF == (uint8_t)json[2]) {
         pi.str = json + 3;
@@ -772,7 +763,7 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.s = pi.str;
     doc_init(doc);
     pi.doc = doc;
-#if IS_WINDOWS
+#if IS_WINDOWS || !defined(HAVE_GETRLIMIT)
     // assume a 1M stack and give half to ruby
     pi.stack_min = (void *)((char *)&pi - (512L * 1024L));
 #else
@@ -787,18 +778,19 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
         }
     }
 #endif
-    self                = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
-    doc->self           = self;
-    doc->json           = json;
-    DATA_PTR(doc->self) = doc;
-    result              = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
+    doc->json = json;
+    self      = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
+    doc->self = self;
+    result    = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
     if (given || 0 != ex) {
         DATA_PTR(doc->self) = NULL;
+        // TBD is this needed?
+        /*
         doc_free(pi.doc);
-        if (allocated && 0 != ex) {  // will jump so caller will not free
-            xfree(json);
+        if (0 != ex) {  // will jump so caller will not free
+            OJ_R_FREE(json);
         }
-        rb_gc_enable();
+        */
     } else {
         result = doc->self;
     }
@@ -1088,31 +1080,23 @@ static void each_value(Doc doc, Leaf leaf) {
  *   doc.close()
  */
 static VALUE doc_open(VALUE clas, VALUE str) {
-    char *         json;
+    char          *json;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
-    int            allocate;
 
     Check_Type(str, T_STRING);
-    len      = (int)RSTRING_LEN(str) + 1;
-    allocate = (SMALL_JSON < len || !given);
-    if (allocate) {
-        json = ALLOC_N(char, len);
-    } else {
-        json = ALLOCA_N(char, len);
-    }
-    // It should not be necessaary to stop GC but if it is not stopped and a
-    // large string is parsed that string is corrupted or freed during
-    // parsing. I'm not sure what is going on exactly but disabling GC avoids
-    // the issue.
-    rb_gc_disable();
+    len  = (int)RSTRING_LEN(str) + 1;
+    json = OJ_R_ALLOC_N(char, len);
+
     memcpy(json, StringValuePtr(str), len);
-    obj = parse_json(clas, json, given, allocate);
-    rb_gc_enable();
-    if (given && allocate) {
-        xfree(json);
+    obj = parse_json(clas, json, given);
+    // TBD is this needed
+    /*
+    if (given) {
+        OJ_R_FREE(json);
     }
+    */
     return obj;
 }
 
@@ -1136,27 +1120,21 @@ static VALUE doc_open(VALUE clas, VALUE str) {
  *   doc.close()
  */
 static VALUE doc_open_file(VALUE clas, VALUE filename) {
-    char *         path;
-    char *         json;
-    FILE *         f;
+    char          *path;
+    char          *json;
+    FILE          *f;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
-    int            allocate;
 
-    Check_Type(filename, T_STRING);
     path = StringValuePtr(filename);
     if (0 == (f = fopen(path, "r"))) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
     }
     fseek(f, 0, SEEK_END);
-    len      = ftell(f);
-    allocate = (SMALL_JSON < len || !given);
-    if (allocate) {
-        json = ALLOC_N(char, len + 1);
-    } else {
-        json = ALLOCA_N(char, len + 1);
-    }
+    len  = ftell(f);
+    json = OJ_R_ALLOC_N(char, len + 1);
+
     fseek(f, 0, SEEK_SET);
     if (len != fread(json, 1, len, f)) {
         fclose(f);
@@ -1167,12 +1145,13 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     }
     fclose(f);
     json[len] = '\0';
-    rb_gc_disable();
-    obj = parse_json(clas, json, given, allocate);
-    rb_gc_enable();
-    if (given && allocate) {
-        xfree(json);
+    obj       = parse_json(clas, json, given);
+    // TBD is this needed
+    /*
+    if (given) {
+        OJ_R_FREE(json);
     }
+    */
     return obj;
 }
 
@@ -1212,11 +1191,11 @@ static VALUE doc_where(VALUE self) {
     if (0 == *doc->where_path || doc->where == doc->where_path) {
         return oj_slash_string;
     } else {
-        Leaf * lp;
+        Leaf  *lp;
         Leaf   leaf;
         size_t size = 3;  // leading / and terminating \0
-        char * path;
-        char * p;
+        char  *path;
+        char  *p;
 
         for (lp = doc->where_path; lp <= doc->where; lp++) {
             leaf = *lp;
@@ -1276,8 +1255,7 @@ static VALUE doc_local_key(VALUE self) {
     volatile VALUE key  = Qnil;
 
     if (T_HASH == leaf->parent_type) {
-        key = rb_str_new2(leaf->key);
-        key = oj_encode(key);
+        key = rb_utf8_str_new_cstr(leaf->key);
     } else if (T_ARRAY == leaf->parent_type) {
         key = LONG2NUM(leaf->index);
     }
@@ -1319,7 +1297,6 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     VALUE       type = Qnil;
 
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
     }
     if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1328,11 +1305,7 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
         case T_TRUE: type = rb_cTrueClass; break;
         case T_FALSE: type = rb_cFalseClass; break;
         case T_STRING: type = rb_cString; break;
-#ifdef RUBY_INTEGER_UNIFICATION
         case T_FIXNUM: type = rb_cInteger; break;
-#else
-        case T_FIXNUM: type = rb_cFixnum; break;
-#endif
         case T_FLOAT: type = rb_cFloat; break;
         case T_ARRAY: type = rb_cArray; break;
         case T_HASH: type = rb_cHash; break;
@@ -1359,11 +1332,10 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     Doc            doc;
     Leaf           leaf;
     volatile VALUE val  = Qnil;
-    const char *   path = 0;
+    const char    *path = 0;
 
     doc = self_doc(self);
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
         if (2 == argc) {
             val = argv[1];
@@ -1388,7 +1360,6 @@ static VALUE doc_exists(VALUE self, VALUE str) {
     Leaf leaf;
 
     doc = self_doc(self);
-    Check_Type(str, T_STRING);
     if (0 != (leaf = get_doc_leaf(doc, StringValuePtr(str)))) {
         if (NULL != leaf) {
             return Qtrue;
@@ -1425,7 +1396,6 @@ static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1460,7 +1430,6 @@ static VALUE doc_move(VALUE self, VALUE str) {
     const char *path;
     int         loc;
 
-    Check_Type(str, T_STRING);
     path = StringValuePtr(str);
     if ('/' == *path) {
         doc->where = doc->where_path;
@@ -1495,14 +1464,13 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         Doc         doc  = self_doc(self);
         const char *path = 0;
         size_t      wlen;
-        Leaf *      where_orig = doc->where;
+        Leaf       *where_orig = doc->where;
 
         wlen = doc->where - doc->where_path;
         if (0 < wlen) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1569,7 +1537,6 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
         Leaf        leaf;
 
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1601,11 +1568,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
 
     if (1 <= argc) {
         if (Qnil != *argv) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (2 <= argc) {
-            Check_Type(argv[1], T_STRING);
             filename = StringValuePtr(argv[1]);
         }
     }
@@ -1617,7 +1582,7 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
 
             oj_out_init(&out);
 
-            out.omit_nil  = oj_default_options.dump_opts.omit_nil;
+            out.omit_nil = oj_default_options.dump_opts.omit_nil;
             oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
             rjson = rb_str_new2(out.buf);
 
@@ -1640,7 +1605,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
  *   Oj::Doc.open('[1,2,3]') { |doc| doc.size() }  #=> 4
  */
 static VALUE doc_size(VALUE self) {
-    return ULONG2NUM(((Doc)DATA_PTR(self))->size);
+    Doc d;
+    TypedData_Get_Struct(self, struct _doc, &oj_doc_type, d);
+    return ULONG2NUM(d->size);
 }
 
 /* @overload close() => nil
@@ -1656,11 +1623,9 @@ static VALUE doc_close(VALUE self) {
     Doc doc = self_doc(self);
 
     rb_gc_unregister_address(&doc->self);
-    DATA_PTR(doc->self) = 0;
+    DATA_PTR(doc->self) = NULL;
     if (0 != doc) {
-        xfree(doc->json);
         doc_free(doc);
-        xfree(doc);
     }
     return Qnil;
 }

data/ext/oj/intern.c

@@ -8,7 +8,9 @@
 #if HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
+
 #include "cache.h"
+#include "mem.h"
 #include "parse.h"
 
 // Only used for the class cache so 256 should be sufficient.
@@ -20,10 +22,10 @@
 
 typedef struct _keyVal {
     struct _keyVal *next;
-    const char *    key;
+    const char     *key;
     size_t          len;
     VALUE           val;
-} * KeyVal;
+} *KeyVal;
 
 typedef struct _hash {
     struct _keyVal slots[HASH_SLOT_CNT];
@@ -32,16 +34,16 @@ typedef struct _hash {
 #else
     VALUE mutex;
 #endif
-} * Hash;
+} *Hash;
 
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static VALUE          str_cache_obj;
+static VALUE str_cache_obj;
 
-static VALUE          sym_cache_obj;
+static VALUE sym_cache_obj;
 
-static VALUE          attr_cache_obj;
+static VALUE attr_cache_obj;
 
 static VALUE form_str(const char *str, size_t len) {
     return rb_str_freeze(rb_utf8_str_new(str, len));
@@ -55,51 +57,59 @@ 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;
 
         if ('~' == *str) {
-	    memcpy(b, str + 1, len - 1);
-	    b[len - 1] = '\0';
-	    len -= 2;
-	} else {
-	    *b = '@';
-	    memcpy(b + 1, str, len);
-	    b[len + 1] = '\0';
-	}
+            memcpy(b, str + 1, len - 1);
+            b[len - 1] = '\0';
+            len -= 2;
+        } else {
+            *b = '@';
+            memcpy(b + 1, str, len);
+            b[len + 1] = '\0';
+        }
         id = rb_intern3(buf, len + 1, oj_utf8_encoding);
-        xfree(b);
+        OJ_R_FREE(b);
         return id;
     }
     if ('~' == *str) {
-	memcpy(buf, str + 1, len - 1);
-	buf[len - 1] = '\0';
-	len -= 2;
+        memcpy(buf, str + 1, len - 1);
+        buf[len - 1] = '\0';
+        len -= 2;
     } else {
-	*buf = '@';
-	memcpy(buf + 1, str, len);
-	buf[len + 1] = '\0';
+        *buf = '@';
+        memcpy(buf + 1, str, len);
+        buf[len + 1] = '\0';
     }
     return (VALUE)rb_intern3(buf, len + 1, oj_utf8_encoding);
 }
 
+static const rb_data_type_t oj_cache_type = {
+    "Oj/cache",
+    {
+        cache_mark,
+        cache_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
 void oj_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
     rb_undef_alloc_func(cache_class);
 
-    rb_gc_register_address(&cache_class);
-    rb_undef_alloc_func(cache_class);
-
-    struct _cache *str_cache     = cache_create(0, form_str, true, true);
-    str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
+    struct _cache *str_cache = cache_create(0, form_str, true, true);
+    str_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    struct _cache *sym_cache     = cache_create(0, form_sym, true, true);
-    sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
+    struct _cache *sym_cache = cache_create(0, form_sym, true, true);
+    sym_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
     struct _cache *attr_cache = cache_create(0, form_attr, false, true);
-    attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
+    attr_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
     memset(class_hash.slots, 0, sizeof(class_hash.slots));
@@ -119,18 +129,23 @@ oj_str_intern(const char *key, size_t len) {
 #if HAVE_RB_ENC_INTERNED_STR && 0
     return rb_enc_interned_str(key, len, rb_utf8_encoding());
 #else
-    return cache_intern(DATA_PTR(str_cache_obj), key, len);
+    Cache c;
+    TypedData_Get_Struct(str_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-  return cache_intern(DATA_PTR(sym_cache_obj), key, len);
+    Cache c;
+    TypedData_Get_Struct(sym_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 }
 
-ID
-oj_attr_intern(const char *key, size_t len) {
-  return cache_intern(DATA_PTR(attr_cache_obj), key, len);
+ID oj_attr_intern(const char *key, size_t len) {
+    Cache c;
+    TypedData_Get_Struct(attr_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
@@ -184,10 +199,10 @@ static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define
 static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
     char        class_name[1024];
     VALUE       clas;
-    char *      end = class_name + sizeof(class_name) - 1;
-    char *      s;
-    const char *n = name;
-    size_t	nlen = len;
+    char       *end = class_name + sizeof(class_name) - 1;
+    char       *s;
+    const char *n    = name;
+    size_t      nlen = len;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
@@ -210,11 +225,11 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-	if (sizeof(class_name) <= nlen) {
-	    nlen = sizeof(class_name) - 1;
-	}
-	strncpy(class_name, name, nlen);
-	class_name[nlen] = '\0';
+        if (sizeof(class_name) <= nlen) {
+            nlen = sizeof(class_name) - 1;
+        }
+        strncpy(class_name, name, nlen);
+        class_name[nlen] = '\0';
         oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class '%s' is not defined", class_name);
         if (Qnil != error_class) {
             pi->err_class = error_class;
@@ -246,7 +261,7 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
                 }
                 bucket = b;
             }
-            b            = ALLOC(struct _keyVal);
+            b            = OJ_R_ALLOC(struct _keyVal);
             b->next      = NULL;
             bucket->next = b;
             bucket       = b;
@@ -267,7 +282,7 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
                 }
                 bucket = b;
             }
-            b            = ALLOC(struct _keyVal);
+            b            = OJ_R_ALLOC(struct _keyVal);
             b->next      = NULL;
             bucket->next = b;
             bucket       = b;
@@ -281,7 +296,7 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
 }
 
 char *oj_strndup(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';

data/ext/oj/intern.h

@@ -4,8 +4,8 @@
 #ifndef OJ_INTERN_H
 #define OJ_INTERN_H
 
-#include <stdbool.h>
 #include <ruby.h>
+#include <stdbool.h>
 
 struct _parseInfo;
 
@@ -14,12 +14,8 @@ extern void oj_hash_init(void);
 extern VALUE oj_str_intern(const char *key, size_t len);
 extern VALUE oj_sym_intern(const char *key, size_t len);
 extern ID    oj_attr_intern(const char *key, size_t len);
-extern VALUE oj_class_intern(const char *       key,
-                             size_t             len,
-                             bool               safe,
-                             struct _parseInfo *pi,
-                             int                auto_define,
-                             VALUE              error_class);
+extern VALUE
+oj_class_intern(const char *key, size_t len, bool safe, struct _parseInfo *pi, int auto_define, VALUE error_class);
 
 extern char *oj_strndup(const char *s, size_t len);