oj 3.13.11 → 3.13.14

data/ext/oj/dump_object.c

@@ -24,12 +24,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
 
     if (rb_cTime == clas) {
         assure_size(out, 6);
-        *out->cur++ = '{';
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = 't';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "{\"^t\":", 6);
         dump_time(obj, out);
         *out->cur++ = '}';
         *out->cur   = '\0';
@@ -91,12 +86,7 @@ static void dump_class(VALUE obj, int depth, Out out, bool as_ok) {
     size_t      len = strlen(s);
 
     assure_size(out, 6);
-    *out->cur++ = '{';
-    *out->cur++ = '"';
-    *out->cur++ = '^';
-    *out->cur++ = 'c';
-    *out->cur++ = '"';
-    *out->cur++ = ':';
+    APPEND_CHARS(out->cur, "{\"^c\":", 6);
     oj_dump_cstr(s, len, 0, 0, out);
     *out->cur++ = '}';
     *out->cur   = '\0';
@@ -120,9 +110,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
     if (0 < id) {
         assure_size(out, d2 * out->indent + 16);
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = 'i';
+        APPEND_CHARS(out->cur, "\"^i", 3);
         dump_ulong(id, out);
         *out->cur++ = '"';
     }
@@ -139,19 +127,17 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
         } else {
             size = d2 * out->indent + 2;
         }
+        assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
-            assure_size(out, size);
             if (out->opts->dump_opts.use) {
                 if (0 < out->opts->dump_opts.array_size) {
-                    strcpy(out->cur, out->opts->dump_opts.array_nl);
-                    out->cur += out->opts->dump_opts.array_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }
                 if (0 < out->opts->dump_opts.indent_size) {
                     int i;
                     for (i = d2; 0 < i; i--) {
-                        strcpy(out->cur, out->opts->dump_opts.indent_str);
-                        out->cur += out->opts->dump_opts.indent_size;
+                        APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                     }
                 }
             } else {
@@ -168,15 +154,13 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
             // printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size,
             // out->opts->dump_opts->indent);
             if (0 < out->opts->dump_opts.array_size) {
-                strcpy(out->cur, out->opts->dump_opts.array_nl);
-                out->cur += out->opts->dump_opts.array_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         } else {
@@ -248,9 +232,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
             uint8_t b;
 
             assure_size(out, s2 + 15);
-            *out->cur++ = '"';
-            *out->cur++ = '^';
-            *out->cur++ = '#';
+            APPEND_CHARS(out->cur, "\"^#", 3);
             out->hash_cnt++;
             for (i = 28; 0 <= i; i -= 4) {
                 b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
@@ -261,9 +243,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                     *out->cur++ = hex_chars[b];
                 }
             }
-            *out->cur++ = '"';
-            *out->cur++ = ':';
-            *out->cur++ = '[';
+            APPEND_CHARS(out->cur, "\":[", 3);
             fill_indent(out, d2);
             oj_dump_obj_val(key, d2, out);
             assure_size(out, s2);
@@ -293,8 +273,7 @@ static void dump_hash_class(VALUE obj, VALUE clas, int depth, Out out) {
     size = depth * out->indent + 2;
     assure_size(out, 2);
     if (0 == cnt) {
-        *out->cur++ = '{';
-        *out->cur++ = '}';
+        APPEND_CHARS(out->cur, "{}", 2);
     } else {
         long id = oj_check_circular(obj, out);
 
@@ -305,11 +284,7 @@ static void dump_hash_class(VALUE obj, VALUE clas, int depth, Out out) {
         if (0 < id) {
             assure_size(out, size + 16);
             fill_indent(out, depth + 1);
-            *out->cur++ = '"';
-            *out->cur++ = '^';
-            *out->cur++ = 'i';
-            *out->cur++ = '"';
-            *out->cur++ = ':';
+            APPEND_CHARS(out->cur, "\"^i\":", 5);
             dump_ulong(id, out);
             *out->cur++ = ',';
         }
@@ -325,15 +300,13 @@ static void dump_hash_class(VALUE obj, VALUE clas, int depth, Out out) {
             size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
             assure_size(out, size);
             if (0 < out->opts->dump_opts.hash_size) {
-                strcpy(out->cur, out->opts->dump_opts.hash_nl);
-                out->cur += out->opts->dump_opts.hash_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         }
@@ -408,11 +381,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
         size = d2 * out->indent + clen + 10;
         assure_size(out, size);
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = 'O';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"^O\":", 5);
         oj_dump_cstr(class_name, clen, 0, 0, out);
         *out->cur++ = ',';
     }
@@ -430,12 +399,9 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
             assure_size(out, size);
             fill_indent(out, d2);
             *out->cur++ = '"';
-            memcpy(out->cur, name, nlen);
-            out->cur += nlen;
-            *out->cur++ = '"';
-            *out->cur++ = ':';
-            memcpy(out->cur, s, len);
-            out->cur += len;
+            APPEND_CHARS(out->cur, name, nlen);
+            APPEND_CHARS(out->cur, "\":", 2);
+            APPEND_CHARS(out->cur, s, len);
             *out->cur = '\0';
         }
     } else {
@@ -446,7 +412,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
             assure_size(out, size);
             name = rb_id2name(*idp);
             nlen = strlen(name);
-            if (0 != *fp) {
+            if (NULL != *fp) {
                 v = (*fp)(obj);
             } else if (0 == strchr(name, '.')) {
                 v = rb_funcall(obj, *idp, 0);
@@ -509,22 +475,14 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
 
         assure_size(out, d2 * out->indent + clen + 10);
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = 'o';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"^o\":", 5);
         oj_dump_cstr(class_name, clen, 0, 0, out);
     }
     if (0 < id) {
         assure_size(out, d2 * out->indent + 16);
         *out->cur++ = ',';
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = 'i';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"^i\":", 5);
         dump_ulong(id, out);
     }
     switch (type) {
@@ -532,39 +490,21 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
         assure_size(out, d2 * out->indent + 14);
         *out->cur++ = ',';
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = 's';
-        *out->cur++ = 'e';
-        *out->cur++ = 'l';
-        *out->cur++ = 'f';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"self\":", 7);
         oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
         break;
     case T_ARRAY:
         assure_size(out, d2 * out->indent + 14);
         *out->cur++ = ',';
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = 's';
-        *out->cur++ = 'e';
-        *out->cur++ = 'l';
-        *out->cur++ = 'f';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"self\":", 7);
         dump_array_class(obj, Qundef, depth + 1, out);
         break;
     case T_HASH:
         assure_size(out, d2 * out->indent + 14);
         *out->cur++ = ',';
         fill_indent(out, d2);
-        *out->cur++ = '"';
-        *out->cur++ = 's';
-        *out->cur++ = 'e';
-        *out->cur++ = 'l';
-        *out->cur++ = 'f';
-        *out->cur++ = '"';
-        *out->cur++ = ':';
+        APPEND_CHARS(out->cur, "\"self\":", 7);
         dump_hash_class(obj, Qundef, depth + 1, out);
         break;
     default: break;
@@ -688,12 +628,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, size);
     *out->cur++ = '{';
     fill_indent(out, d2);
-    *out->cur++ = '"';
-    *out->cur++ = '^';
-    *out->cur++ = 'u';
-    *out->cur++ = '"';
-    *out->cur++ = ':';
-    *out->cur++ = '[';
+    APPEND_CHARS(out->cur, "\"^u\":[", 6);
     if ('#' == *class_name) {
         VALUE       ma = rb_struct_s_members(clas);
         const char *name;
@@ -711,16 +646,14 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
                 *out->cur++ = ',';
             }
             *out->cur++ = '"';
-            memcpy(out->cur, name, len);
-            out->cur += len;
+            APPEND_CHARS(out->cur, name, len);
             *out->cur++ = '"';
         }
         *out->cur++ = ']';
     } else {
         fill_indent(out, d3);
         *out->cur++ = '"';
-        memcpy(out->cur, class_name, len);
-        out->cur += len;
+        APPEND_CHARS(out->cur, class_name, len);
         *out->cur++ = '"';
     }
     *out->cur++ = ',';
@@ -764,8 +697,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     }
 #endif
     out->cur--;
-    *out->cur++ = ']';
-    *out->cur++ = '}';
+    APPEND_CHARS(out->cur, "]}", 2);
     *out->cur   = '\0';
 }
 

data/ext/oj/dump_strict.c

@@ -105,9 +105,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         }
     }
     assure_size(out, cnt);
-    for (b = buf; '\0' != *b; b++) {
-        *out->cur++ = *b;
-    }
+    APPEND_CHARS(out->cur, buf, cnt);
     *out->cur = '\0';
 }
 
@@ -134,19 +132,17 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         } else {
             size = d2 * out->indent + 2;
         }
+        assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
-            assure_size(out, size);
             if (out->opts->dump_opts.use) {
                 if (0 < out->opts->dump_opts.array_size) {
-                    strcpy(out->cur, out->opts->dump_opts.array_nl);
-                    out->cur += out->opts->dump_opts.array_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }
                 if (0 < out->opts->dump_opts.indent_size) {
                     int i;
                     for (i = d2; 0 < i; i--) {
-                        strcpy(out->cur, out->opts->dump_opts.indent_str);
-                        out->cur += out->opts->dump_opts.indent_size;
+                        APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                     }
                 }
             } else {
@@ -167,15 +163,13 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             // printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size,
             // out->opts->dump_opts->indent);
             if (0 < out->opts->dump_opts.array_size) {
-                strcpy(out->cur, out->opts->dump_opts.array_nl);
-                out->cur += out->opts->dump_opts.array_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         } else {
@@ -214,14 +208,12 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
         assure_size(out, size);
         if (0 < out->opts->dump_opts.hash_size) {
-            strcpy(out->cur, out->opts->dump_opts.hash_nl);
-            out->cur += out->opts->dump_opts.hash_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
         }
         if (0 < out->opts->dump_opts.indent_size) {
             int i;
             for (i = depth; 0 < i; i--) {
-                strcpy(out->cur, out->opts->dump_opts.indent_str);
-                out->cur += out->opts->dump_opts.indent_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
         if (rtype == T_STRING) {
@@ -232,13 +224,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
         if (0 < out->opts->dump_opts.before_size) {
-            strcpy(out->cur, out->opts->dump_opts.before_sep);
-            out->cur += out->opts->dump_opts.before_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
         }
         *out->cur++ = ':';
         if (0 < out->opts->dump_opts.after_size) {
-            strcpy(out->cur, out->opts->dump_opts.after_sep);
-            out->cur += out->opts->dump_opts.after_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
         }
     }
     if (NullMode == out->opts->mode) {
@@ -281,15 +271,13 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
             assure_size(out, size);
             if (0 < out->opts->dump_opts.hash_size) {
-                strcpy(out->cur, out->opts->dump_opts.hash_nl);
-                out->cur += out->opts->dump_opts.hash_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         }

data/ext/oj/fast.c

@@ -13,6 +13,7 @@
 
 #include "encode.h"
 #include "oj.h"
+#include "dump.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_JSON 65536
@@ -771,7 +772,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;
@@ -1610,18 +1611,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;
+            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;
@@ -1717,8 +1715,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

@@ -86,8 +86,12 @@ static VALUE form_attr(const char *str, size_t len) {
     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);
+
+    rb_gc_register_address(&cache_class);
+    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);
@@ -275,6 +279,7 @@ 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;
 }
 
@@ -287,8 +292,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

@@ -9,7 +9,7 @@
 
 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);

data/ext/oj/mimic_json.c

@@ -198,7 +198,6 @@ static int mimic_limit_arg(VALUE a) {
  * Returns [_String_] a JSON string.
  */
 static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     struct _options copts = oj_default_options;
     VALUE           rstr;
@@ -206,9 +205,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
+
+    oj_out_init(&out);
+
     out.caller        = CALLER_DUMP;
     copts.escape_mode = JXEsc;
     copts.mode        = CompatMode;
@@ -257,9 +256,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
         rb_funcall2(io, oj_write_id, 1, args);
         rstr = io;
     }
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -358,15 +357,16 @@ static VALUE mimic_dump_load(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
-    char        buf[4096];
     struct _out out;
     VALUE       rstr;
 
-    memset(buf, 0, sizeof(buf));
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    memset(out.stack_buffer, 0, sizeof(out.stack_buffer));
+
+    oj_out_init(&out);
 
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - 10;
-    out.allocated = false;
     out.omit_nil  = copts->dump_opts.omit_nil;
     out.caller    = CALLER_GENERATE;
     // For obj.to_json or generate nan is not allowed but if called from dump
@@ -398,9 +398,9 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -457,9 +457,12 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     // a Hash. I haven't dug deep enough to find out why but using a State
     // instance and not a Hash gives the desired behavior.
     *rargs = *argv;
-    if (1 == argc) {
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
-    } else {
+    } else  {
         h = argv[1];
     }
     if (!oj_hash_has_key(h, oj_indent_sym)) {
@@ -740,16 +743,15 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        }};
 
 static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     VALUE           rstr;
     struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
+
+    oj_out_init(&out);
+
     out.omit_nil      = copts.dump_opts.omit_nil;
     copts.mode        = CompatMode;
     copts.to_json     = No;
@@ -765,9 +767,9 @@ static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }