oj 3.13.11 → 3.15.0

data/ext/oj/sparse.c

@@ -10,6 +10,7 @@
 #include "buf.h"
 #include "encode.h"
 #include "intern.h"  // for oj_strndup()
+#include "mem.h"
 #include "oj.h"
 #include "parse.h"
 #include "val_stack.h"
@@ -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;
@@ -212,11 +213,7 @@ static void read_escaped_str(ParseInfo pi) {
     }
     while ('\"' != (c = reader_get(&pi->rd))) {
         if ('\0' == c) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "quoted string not terminated");
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
             buf_cleanup(&buf);
             return;
         } else if ('\\' == c) {
@@ -249,11 +246,7 @@ static void read_escaped_str(ParseInfo pi) {
                             reader_backup(&pi->rd);
                             break;
                         }
-                        oj_set_error_at(pi,
-                                        oj_parse_error_class,
-                                        __FILE__,
-                                        __LINE__,
-                                        "invalid escaped character");
+                        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
                         buf_cleanup(&buf);
                         return;
                     }
@@ -277,11 +270,7 @@ static void read_escaped_str(ParseInfo pi) {
                     buf_append(&buf, c);
                     break;
                 }
-                oj_set_error_at(pi,
-                                oj_parse_error_class,
-                                __FILE__,
-                                __LINE__,
-                                "invalid escaped character");
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
                 buf_cleanup(&buf);
                 return;
             }
@@ -315,7 +304,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;
@@ -345,11 +334,7 @@ static void read_str(ParseInfo pi) {
     reader_protect(&pi->rd);
     while ('\"' != (c = reader_get(&pi->rd))) {
         if ('\0' == c) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "quoted string not terminated");
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
             return;
         } else if ('\\' == c) {
             reader_backup(&pi->rd);
@@ -386,7 +371,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;
@@ -429,7 +414,7 @@ static void read_num(ParseInfo pi) {
         ni.no_big      = !pi->options.compat_bigdec;
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
-        ni.no_big = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
+        ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
                      RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
@@ -443,18 +428,10 @@ static void read_num(ParseInfo pi) {
     }
     if ('I' == c) {
         if (No == pi->options.allow_nan) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "not a number or other value");
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
             return;
         } else if (0 != reader_expect(&pi->rd, "nfinity")) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "not a number or other value");
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
             return;
         }
         ni.infinity = 1;
@@ -476,11 +453,7 @@ static void read_num(ParseInfo pi) {
 
                 if (0 < d) {
                     if (zero1 && CompatMode == pi->options.mode) {
-                        oj_set_error_at(pi,
-                                        oj_parse_error_class,
-                                        __FILE__,
-                                        __LINE__,
-                                        "not a number");
+                        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
                         return;
                     }
                     zero1 = false;
@@ -591,7 +564,7 @@ static void read_nan(ParseInfo pi) {
         ni.no_big      = !pi->options.compat_bigdec;
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
-        ni.no_big = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
+        ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
                      RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
@@ -716,11 +689,7 @@ void oj_sparse2(ParseInfo pi) {
         case '"': read_str(pi); break;
         case '+':
             if (CompatMode == pi->options.mode) {
-                oj_set_error_at(pi,
-                                oj_parse_error_class,
-                                __FILE__,
-                                __LINE__,
-                                "unexpected character");
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
                 return;
             }
             pi->cur--;
@@ -745,11 +714,7 @@ void oj_sparse2(ParseInfo pi) {
                 reader_backup(&pi->rd);
                 read_num(pi);
             } else {
-                oj_set_error_at(pi,
-                                oj_parse_error_class,
-                                __FILE__,
-                                __LINE__,
-                                "unexpected character");
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
                 return;
             }
             break;
@@ -757,11 +722,7 @@ void oj_sparse2(ParseInfo pi) {
             if (Yes == pi->options.allow_nan) {
                 read_nan(pi);
             } else {
-                oj_set_error_at(pi,
-                                oj_parse_error_class,
-                                __FILE__,
-                                __LINE__,
-                                "unexpected character");
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
                 return;
             }
             break;
@@ -799,8 +760,7 @@ void oj_sparse2(ParseInfo pi) {
                     ni.no_big      = !pi->options.compat_bigdec;
                     ni.bigdec_load = pi->options.compat_bigdec;
                 } else {
-                    ni.no_big      = (FloatDec == pi->options.bigdec_load ||
-                                 FastDec == pi->options.bigdec_load ||
+                    ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
                                  RubyDec == pi->options.bigdec_load);
                     ni.bigdec_load = pi->options.bigdec_load;
                 }
@@ -813,13 +773,7 @@ void oj_sparse2(ParseInfo pi) {
         case '/': skip_comment(pi); break;
         case '\0': return;
         default:
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "unexpected character '%c' [0x%02x]",
-                            c,
-                            c);
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character '%c' [0x%02x]", c, c);
             return;
         }
         if (err_has(&pi->err)) {
@@ -878,8 +832,8 @@ oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd) {
         } else {
             rb_raise(rb_eTypeError, "Nil is not a valid JSON source.");
         }
-    } else if (CompatMode == pi->options.mode && T_STRING == rb_type(input) &&
-               No == pi->options.nilnil && 0 == RSTRING_LEN(input)) {
+    } else if (CompatMode == pi->options.mode && T_STRING == rb_type(input) && No == pi->options.nilnil &&
+               0 == RSTRING_LEN(input)) {
         rb_raise(oj_json_parser_error_class, "An empty string is not a valid JSON string.");
     }
     if (rb_block_given_p()) {
@@ -932,9 +886,7 @@ oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd) {
             switch (v->next) {
             case NEXT_ARRAY_NEW:
             case NEXT_ARRAY_ELEMENT:
-            case NEXT_ARRAY_COMMA:
-                oj_set_error_at(pi, err_class, __FILE__, __LINE__, "Array not terminated");
-                break;
+            case NEXT_ARRAY_COMMA: oj_set_error_at(pi, err_class, __FILE__, __LINE__, "Array not terminated"); break;
             case NEXT_HASH_NEW:
             case NEXT_HASH_KEY:
             case NEXT_HASH_COLON:
@@ -953,7 +905,11 @@ CLEANUP:
     }
     stack_cleanup(&pi->stack);
     if (0 != fd) {
+#ifdef _WIN32
+        rb_w32_close(fd);
+#else
         close(fd);
+#endif
     }
     if (err_has(&pi->err)) {
         rb_set_errinfo(Qnil);

data/ext/oj/stream_writer.c

@@ -5,6 +5,7 @@
 #include <ruby.h>
 
 #include "encode.h"
+#include "mem.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) {
@@ -82,8 +83,8 @@ static VALUE stream_writer_new(int argc, VALUE *argv, VALUE self) {
     if (oj_stringio_class == clas) {
         type = STRING_IO;
 #if !IS_WINDOWS
-    } else if (rb_respond_to(stream, oj_fileno_id) &&
-               Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) && 0 != (fd = FIX2INT(s))) {
+    } else if (rb_respond_to(stream, oj_fileno_id) && Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
+               0 != (fd = FIX2INT(s))) {
         type = FILE_IO;
 #endif
     } else if (rb_respond_to(stream, oj_write_id)) {
@@ -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;
@@ -101,15 +102,10 @@ static VALUE stream_writer_new(int argc, VALUE *argv, VALUE self) {
             rb_gc_register_address(&buffer_size_sym);
         }
         if (Qnil != (v = rb_hash_lookup(argv[1], buffer_size_sym))) {
-#ifdef RUBY_INTEGER_UNIFICATION
             if (rb_cInteger != rb_obj_class(v)) {
+                OJ_R_FREE(sw);
                 rb_raise(rb_eArgError, ":buffer size must be a Integer.");
             }
-#else
-            if (T_FIXNUM != rb_type(v)) {
-                rb_raise(rb_eArgError, ":buffer size must be a Integer.");
-            }
-#endif
             buf_size = FIX2INT(v);
         }
         oj_str_writer_init(&sw->sw, buf_size);
@@ -139,7 +135,6 @@ static VALUE stream_writer_new(int argc, VALUE *argv, VALUE self) {
 static VALUE stream_writer_push_key(VALUE self, VALUE key) {
     StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
-    rb_check_type(key, T_STRING);
     oj_str_writer_push_key(&sw->sw, StringValuePtr(key));
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
         stream_writer_write(sw);
@@ -164,7 +159,6 @@ static VALUE stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[0]) {
             oj_str_writer_push_object(&sw->sw, 0);
         } else {
-            rb_check_type(argv[0], T_STRING);
             oj_str_writer_push_object(&sw->sw, StringValuePtr(argv[0]));
         }
         break;
@@ -193,7 +187,6 @@ static VALUE stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[0]) {
             oj_str_writer_push_array(&sw->sw, 0);
         } else {
-            rb_check_type(argv[0], T_STRING);
             oj_str_writer_push_array(&sw->sw, StringValuePtr(argv[0]));
         }
         break;
@@ -221,7 +214,6 @@ static VALUE stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[1]) {
             oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
         } else {
-            rb_check_type(argv[1], T_STRING);
             oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
         }
         break;
@@ -245,17 +237,13 @@ static VALUE stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
 static VALUE stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
     StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
-    rb_check_type(argv[0], T_STRING);
     switch (argc) {
     case 1: oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0); break;
     case 2:
         if (Qnil == argv[1]) {
             oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
         } else {
-            rb_check_type(argv[1], T_STRING);
-            oj_str_writer_push_json((StrWriter)DATA_PTR(self),
-                                    StringValuePtr(*argv),
-                                    StringValuePtr(argv[1]));
+            oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
         }
         break;
     default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'."); break;
@@ -315,8 +303,10 @@ static VALUE stream_writer_flush(VALUE self) {
  * will create that element in the JSON document and subsequent pushes will add
  * the elements to that array or object until a pop() is called.
  */
-void oj_stream_writer_init() {
+void oj_stream_writer_init(void) {
     oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
+    rb_gc_register_address(&oj_stream_writer_class);
+    rb_undef_alloc_func(oj_stream_writer_class);
     rb_define_module_function(oj_stream_writer_class, "new", stream_writer_new, -1);
     rb_define_method(oj_stream_writer_class, "push_key", stream_writer_push_key, 1);
     rb_define_method(oj_stream_writer_class, "push_object", stream_writer_push_object, -1);

data/ext/oj/strict.c

@@ -17,7 +17,7 @@ VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str) {
     volatile VALUE rstr = Qnil;
 
     if (len < cache_str) {
-	rstr = oj_str_intern(str, len);
+        rstr = oj_str_intern(str, len);
     } else {
         rstr = rb_str_new(str, len);
         rstr = oj_encode(rstr);
@@ -37,28 +37,24 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
         } else {
             rkey = rb_str_new(parent->key, parent->klen);
             rkey = oj_encode(rkey);
-	    OBJ_FREEZE(rkey); // frozen when used as a Hash key anyway
+            OBJ_FREEZE(rkey);  // frozen when used as a Hash key anyway
         }
         return rkey;
     }
     if (Yes == pi->options.sym_key) {
-	rkey = oj_sym_intern(parent->key, parent->klen);
+        rkey = oj_sym_intern(parent->key, parent->klen);
     } else {
-	rkey = oj_str_intern(parent->key, parent->klen);
+        rkey = oj_str_intern(parent->key, parent->klen);
     }
     return rkey;
 }
 
 static void hash_end(ParseInfo pi) {
-    if (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 (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) {
@@ -66,9 +62,7 @@ static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
 }
 
 static void add_value(ParseInfo pi, VALUE val) {
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_value", pi, val);
     pi->stack.head->val = val;
 }
 
@@ -76,9 +70,7 @@ static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     pi->stack.head->val = rstr;
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, rstr);
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
@@ -86,30 +78,22 @@ static void add_num(ParseInfo pi, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     pi->stack.head->val = oj_num_as_value(ni);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, pi->stack.head->val);
 }
 
 static VALUE start_hash(ParseInfo pi) {
     if (Qnil != pi->options.hash_class) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
-    if (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();
 }
 
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rb_hash_aset(stack_peek(&pi->stack)->val,
-                 oj_calc_hash_key(pi, parent),
-                 rstr);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
-    }
+    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
 }
 
 static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
@@ -119,27 +103,17 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val,
-                 oj_calc_hash_key(pi, parent),
-                 v);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, v);
-    }
+    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, v);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val,
-                 oj_calc_hash_key(pi, parent),
-                 value);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
-    }
+    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 
 static VALUE start_array(ParseInfo pi) {
-    if (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();
 }
 
@@ -147,9 +121,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
 static void array_append_num(ParseInfo pi, NumInfo ni) {
@@ -160,16 +132,12 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     }
     v = oj_num_as_value(ni);
     rb_ary_push(stack_peek(&pi->stack)->val, v);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, v);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, v);
 }
 
 static void array_append_value(ParseInfo pi, VALUE value) {
     rb_ary_push(stack_peek(&pi->stack)->val, value);
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_value", pi, value);
 }
 
 void oj_set_strict_callbacks(ParseInfo pi) {

data/ext/oj/string_writer.c

@@ -3,6 +3,7 @@
 
 #include "dump.h"
 #include "encode.h"
+#include "mem.h"
 
 extern VALUE Oj;
 
@@ -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;
@@ -53,10 +54,13 @@ void oj_str_writer_init(StrWriter sw, int buf_size) {
     } else if (buf_size < 1024) {
         buf_size = 1024;
     }
-    sw->out.buf        = ALLOC_N(char, buf_size);
-    sw->out.end        = sw->out.buf + buf_size - 10;
-    sw->out.allocated  = true;
-    sw->out.cur        = sw->out.buf;
+    // Must be allocated. Using the out.stack_buffer results in double frees
+    // and I haven't figured out why yet.
+    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;
+
     *sw->out.cur       = '\0';
     sw->out.circ_cache = NULL;
     sw->out.circ_cnt   = 0;
@@ -229,9 +233,11 @@ static void str_writer_free(void *ptr) {
         return;
     }
     sw = (StrWriter)ptr;
-    xfree(sw->out.buf);
-    xfree(sw->types);
-    xfree(ptr);
+
+    oj_out_free(&sw->out);
+
+    OJ_R_FREE(sw->types);
+    OJ_R_FREE(ptr);
 }
 
 /* Document-method: new
@@ -251,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) {
@@ -275,7 +281,6 @@ static VALUE str_writer_new(int argc, VALUE *argv, VALUE self) {
 static VALUE str_writer_push_key(VALUE self, VALUE key) {
     StrWriter sw = (StrWriter)DATA_PTR(self);
 
-    rb_check_type(key, T_STRING);
     oj_str_writer_push_key(sw, StringValuePtr(key));
 
     return Qnil;
@@ -297,7 +302,6 @@ static VALUE str_writer_push_object(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[0]) {
             oj_str_writer_push_object(sw, 0);
         } else {
-            rb_check_type(argv[0], T_STRING);
             oj_str_writer_push_object(sw, StringValuePtr(argv[0]));
         }
         break;
@@ -326,7 +330,6 @@ static VALUE str_writer_push_array(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[0]) {
             oj_str_writer_push_array(sw, 0);
         } else {
-            rb_check_type(argv[0], T_STRING);
             oj_str_writer_push_array(sw, StringValuePtr(argv[0]));
         }
         break;
@@ -353,7 +356,6 @@ static VALUE str_writer_push_value(int argc, VALUE *argv, VALUE self) {
         if (Qnil == argv[1]) {
             oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
         } else {
-            rb_check_type(argv[1], T_STRING);
             oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
         }
         break;
@@ -372,17 +374,13 @@ static VALUE str_writer_push_value(int argc, VALUE *argv, VALUE self) {
  * - *key* [_String_] the key if adding to an object in the JSON document
  */
 static VALUE str_writer_push_json(int argc, VALUE *argv, VALUE self) {
-    rb_check_type(argv[0], T_STRING);
     switch (argc) {
     case 1: oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0); break;
     case 2:
         if (Qnil == argv[1]) {
             oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
         } else {
-            rb_check_type(argv[1], T_STRING);
-            oj_str_writer_push_json((StrWriter)DATA_PTR(self),
-                                    StringValuePtr(*argv),
-                                    StringValuePtr(argv[1]));
+            oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
         }
         break;
     default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'."); break;
@@ -449,7 +447,7 @@ static VALUE str_writer_to_s(VALUE self) {
  * Returns the contents of the writer as a JSON element. If called from inside
  * an array or hash by Oj the raw buffer will be used othersize a more
  * inefficient parse of the contents and a return of the result is
- * completed. The parse uses the trict mode.
+ * completed. The parse uses the strict mode.
  *
  * *return* [_Hash_|_Array_|_String_|_Integer_|_Float_|_True_|_False_|_nil|)
  */
@@ -469,8 +467,10 @@ static VALUE str_writer_as_json(VALUE self) {
  * calling to_s() will return the JSON document. Note that calling to_s() before
  * construction is complete will return the document in it's current state.
  */
-void oj_string_writer_init() {
+void oj_string_writer_init(void) {
     oj_string_writer_class = rb_define_class_under(Oj, "StringWriter", rb_cObject);
+    rb_gc_register_address(&oj_string_writer_class);
+    rb_undef_alloc_func(oj_string_writer_class);
     rb_define_module_function(oj_string_writer_class, "new", str_writer_new, -1);
     rb_define_method(oj_string_writer_class, "push_key", str_writer_push_key, 1);
     rb_define_method(oj_string_writer_class, "push_object", str_writer_push_object, -1);