oj 3.13.11 → 3.15.0

data/ext/oj/fast.c

@@ -11,13 +11,15 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "dump.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.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
@@ -31,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);
@@ -73,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);
@@ -159,7 +161,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));
@@ -249,7 +251,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;
@@ -355,7 +357,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;
 
@@ -647,10 +649,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);
     }
 }
 
@@ -670,27 +673,28 @@ static void free_doc_cb(void *x) {
     Doc doc = (Doc)x;
 
     if (0 != doc) {
-        xfree(doc->json);
         doc_free(doc);
     }
 }
 
 static void mark_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                mark_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: mark(leaf->value); break;
+                do {
+                    mark_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: mark(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 
@@ -746,20 +750,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;
@@ -771,7 +770,7 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.doc = doc;
 #if IS_WINDOWS
     // assume a 1M stack and give half to ruby
-    pi.stack_min = (void *)((char *)&pi - (512 * 1024));
+    pi.stack_min = (void *)((char *)&pi - (512L * 1024L));
 #else
     {
         struct rlimit lim;
@@ -784,18 +783,20 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
         }
     }
 #endif
+    doc->json           = json;
     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);
     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;
     }
@@ -1085,31 +1086,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;
 }
 
@@ -1133,27 +1126,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);
@@ -1164,12 +1151,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;
 }
 
@@ -1209,11 +1197,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;
@@ -1316,7 +1304,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))) {
@@ -1325,11 +1312,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;
@@ -1356,11 +1339,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];
@@ -1385,7 +1367,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;
@@ -1422,7 +1403,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;
@@ -1457,7 +1437,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;
@@ -1492,14 +1471,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;
@@ -1566,7 +1544,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))) {
@@ -1598,11 +1575,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]);
         }
     }
@@ -1610,18 +1585,15 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
         volatile VALUE rjson;
 
         if (0 == filename) {
-            char        buf[4096];
             struct _out out;
 
-            out.buf       = buf;
-            out.end       = buf + sizeof(buf) - 10;
-            out.allocated = false;
-            out.omit_nil  = oj_default_options.dump_opts.omit_nil;
+            oj_out_init(&out);
+
+            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);
-            if (out.allocated) {
-                xfree(out.buf);
-            }
+
+            oj_out_free(&out);
         } else {
             oj_write_leaf_to_file(leaf, filename, &oj_default_options);
             rjson = Qnil;
@@ -1656,11 +1628,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;
 }
@@ -1717,8 +1687,10 @@ static VALUE doc_not_implemented(VALUE self) {
  *   # Now try again using a path to Oj::Doc.fetch() directly and not using a
  * block. doc = Oj::Doc.open(json) doc.fetch('/2/three')  #=> 3 doc.close()
  */
-void oj_init_doc() {
+void oj_init_doc(void) {
     oj_doc_class = rb_define_class_under(Oj, "Doc", rb_cObject);
+    rb_gc_register_address(&oj_doc_class);
+    rb_undef_alloc_func(oj_doc_class);
     rb_define_singleton_method(oj_doc_class, "open", doc_open, 1);
     rb_define_singleton_method(oj_doc_class, "open_file", doc_open_file, 1);
     rb_define_singleton_method(oj_doc_class, "parse", doc_open, 1);

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,19 +34,16 @@ typedef struct _hash {
 #else
     VALUE mutex;
 #endif
-} * Hash;
+} *Hash;
 
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static struct _cache *str_cache = NULL;
-static VALUE          str_cache_obj;
+static VALUE str_cache_obj;
 
-static struct _cache *sym_cache = NULL;
-static VALUE          sym_cache_obj;
+static VALUE sym_cache_obj;
 
-static struct _cache *attr_cache = NULL;
-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));
@@ -58,47 +57,48 @@ 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);
 }
 
-void oj_hash_init() {
+void oj_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
+    rb_undef_alloc_func(cache_class);
 
-    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            = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    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            = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
-    attr_cache     = cache_create(0, form_attr, false, true);
-    attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
+    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);
     rb_gc_register_address(&attr_cache_obj);
 
     memset(class_hash.slots, 0, sizeof(class_hash.slots));
@@ -118,18 +118,17 @@ 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(str_cache, key, len);
+    return cache_intern(DATA_PTR(str_cache_obj), key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-    return cache_intern(sym_cache, key, len);
+    return cache_intern(DATA_PTR(sym_cache_obj), key, len);
 }
 
-ID
-oj_attr_intern(const char *key, size_t len) {
-    return cache_intern(attr_cache, key, len);
+ID oj_attr_intern(const char *key, size_t len) {
+    return cache_intern(DATA_PTR(attr_cache_obj), key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
@@ -183,10 +182,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--) {
@@ -209,11 +208,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;
@@ -245,7 +244,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;
@@ -266,7 +265,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;
@@ -275,11 +274,12 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
         bucket->len = len;
         bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
     }
+    rb_gc_register_mark_object(bucket->val);
     return bucket->val;
 }
 
 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';
@@ -287,8 +287,10 @@ char *oj_strndup(const char *s, size_t len) {
     return d;
 }
 
-void intern_cleanup() {
+/*
+void intern_cleanup(void) {
     cache_free(str_cache);
     cache_free(sym_cache);
     cache_free(attr_cache);
 }
+*/

data/ext/oj/intern.h

@@ -4,22 +4,18 @@
 #ifndef OJ_INTERN_H
 #define OJ_INTERN_H
 
-#include <stdbool.h>
 #include <ruby.h>
+#include <stdbool.h>
 
 struct _parseInfo;
 
-extern void oj_hash_init();
+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);