oj 3.11.5 → 3.16.5

data/ext/oj/dump.c

@@ -10,8 +10,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#if !IS_WINDOWS
+#include <poll.h>
+#endif
 
 #include "cache8.h"
+#include "mem.h"
 #include "odd.h"
 #include "oj.h"
 #include "trace.h"
@@ -29,6 +33,7 @@ static const char nan_val[]  = NAN_VAL;
 typedef unsigned long ulong;
 
 static size_t hibit_friendly_size(const uint8_t *str, size_t len);
+static size_t slash_friendly_size(const uint8_t *str, size_t len);
 static size_t xss_friendly_size(const uint8_t *str, size_t len);
 static size_t ascii_friendly_size(const uint8_t *str, size_t len);
 
@@ -56,6 +61,17 @@ static char hibit_friendly_chars[256] = "\
 11111111111111111111111111111111\
 11111111111111111111111111111111";
 
+// JSON standard but escape forward slashes `/`
+static char slash_friendly_chars[256] = "\
+66666666222622666666666666666666\
+11211111111111121111111111111111\
+11111111111111111111111111112111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111";
+
 // High bit set characters are always encoded as unicode. Worse case is 3
 // bytes per character in the output. That makes this conservative.
 static char ascii_friendly_chars[256] = "\
@@ -113,49 +129,43 @@ static char rails_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 static void raise_strict(VALUE obj) {
-    rb_raise(rb_eTypeError,
-             "Failed to dump %s Object to JSON in strict mode.",
-             rb_class2name(rb_obj_class(obj)));
+    rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.", rb_class2name(rb_obj_class(obj)));
 }
 
-inline static size_t newline_friendly_size(const uint8_t *str, size_t len) {
+inline static size_t calculate_string_size(const uint8_t *str, size_t len, const char *table) {
     size_t size = 0;
     size_t i    = len;
 
-    for (; 0 < i; str++, i--) {
-        size += newline_friendly_chars[*str];
+    for (; 3 < i; i -= 4) {
+        size += table[*str++];
+        size += table[*str++];
+        size += table[*str++];
+        size += table[*str++];
+    }
+    for (; 0 < i; i--) {
+        size += table[*str++];
     }
     return size - len * (size_t)'0';
 }
 
+inline static size_t newline_friendly_size(const uint8_t *str, size_t len) {
+    return calculate_string_size(str, len, newline_friendly_chars);
+}
+
 inline static size_t hibit_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
+    return calculate_string_size(str, len, hibit_friendly_chars);
+}
 
-    for (; 0 < i; str++, i--) {
-        size += hibit_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+inline static size_t slash_friendly_size(const uint8_t *str, size_t len) {
+    return calculate_string_size(str, len, slash_friendly_chars);
 }
 
 inline static size_t ascii_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
-
-    for (; 0 < i; str++, i--) {
-        size += ascii_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+    return calculate_string_size(str, len, ascii_friendly_chars);
 }
 
 inline static size_t xss_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
-
-    for (; 0 < i; str++, i--) {
-        size += xss_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+    return calculate_string_size(str, len, xss_friendly_chars);
 }
 
 inline static size_t hixss_friendly_size(const uint8_t *str, size_t len) {
@@ -188,13 +198,18 @@ inline static long rails_xss_friendly_size(const uint8_t *str, size_t len) {
 }
 
 inline static size_t rails_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
+    long    size = 0;
+    size_t  i    = len;
+    uint8_t hi   = 0;
 
     for (; 0 < i; str++, i--) {
         size += rails_friendly_chars[*str];
+        hi |= *str & 0x80;
     }
-    return size - len * (size_t)'0';
+    if (0 == hi) {
+        return size - len * (size_t)'0';
+    }
+    return -(size - len * (size_t)'0');
 }
 
 const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, int *lenp) {
@@ -247,7 +262,7 @@ inline static void dump_hex(uint8_t c, Out out) {
 static void raise_invalid_unicode(const char *str, int len, int pos) {
     char    c;
     char    code[32];
-    char *  cp = code;
+    char   *cp = code;
     int     i;
     uint8_t d;
 
@@ -302,16 +317,14 @@ static const char *dump_unicode(const char *str, const char *end, Out out, const
         uint32_t c1;
 
         code -= 0x00010000;
-        c1          = ((code >> 10) & 0x000003FF) + 0x0000D800;
-        code        = (code & 0x000003FF) + 0x0000DC00;
-        *out->cur++ = '\\';
-        *out->cur++ = 'u';
+        c1   = ((code >> 10) & 0x000003FF) + 0x0000D800;
+        code = (code & 0x000003FF) + 0x0000DC00;
+        APPEND_CHARS(out->cur, "\\u", 2);
         for (i = 3; 0 <= i; i--) {
             *out->cur++ = hex_chars[(uint8_t)(c1 >> (i * 4)) & 0x0F];
         }
     }
-    *out->cur++ = '\\';
-    *out->cur++ = 'u';
+    APPEND_CHARS(out->cur, "\\u", 2);
     for (i = 3; 0 <= i; i--) {
         *out->cur++ = hex_chars[(uint8_t)(code >> (i * 4)) & 0x0F];
     }
@@ -360,9 +373,7 @@ long oj_check_circular(VALUE obj, Out out) {
         } else {
             if (ObjectMode == out->opts->mode) {
                 assure_size(out, 18);
-                *out->cur++ = '"';
-                *out->cur++ = '^';
-                *out->cur++ = 'r';
+                APPEND_CHARS(out->cur, "\"^r", 3);
                 dump_ulong(id, out);
                 *out->cur++ = '"';
             }
@@ -374,15 +385,14 @@ long oj_check_circular(VALUE obj, Out out) {
 
 void oj_dump_time(VALUE obj, Out out, int withZone) {
     char      buf[64];
-    char *    b = buf + sizeof(buf) - 1;
+    char     *b = buf + sizeof(buf) - 1;
     long      size;
-    char *    dot;
+    char     *dot;
     int       neg = 0;
     long      one = 1000000000;
     long long sec;
     long long nsec;
 
-#ifdef HAVE_RB_TIME_TIMESPEC
     // rb_time_timespec as well as rb_time_timeeval have a bug that causes an
     // exception to be raised if a time is before 1970 on 32 bit systems so
     // check the timespec size and use the ruby calls if a 32 bit system.
@@ -392,13 +402,9 @@ void oj_dump_time(VALUE obj, Out out, int withZone) {
         sec  = (long long)ts.tv_sec;
         nsec = ts.tv_nsec;
     } else {
-        sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+        sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
     }
-#else
-    sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-    nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
-#endif
 
     *b-- = '\0';
     if (withZone) {
@@ -464,15 +470,14 @@ void oj_dump_time(VALUE obj, Out out, int withZone) {
     b++;
     size = sizeof(buf) - (b - buf) - 1;
     assure_size(out, size);
-    memcpy(out->cur, b, size);
-    out->cur += size;
+    APPEND_CHARS(out->cur, b, size);
     *out->cur = '\0';
 }
 
 void oj_dump_ruby_time(VALUE obj, Out out) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_xml_time(VALUE obj, Out out) {
@@ -485,20 +490,15 @@ void oj_dump_xml_time(VALUE obj, Out out) {
     int              tzhour, tzmin;
     char             tzsign = '+';
 
-#ifdef HAVE_RB_TIME_TIMESPEC
     if (16 <= sizeof(struct timespec)) {
         struct timespec ts = rb_time_timespec(obj);
 
         sec  = ts.tv_sec;
         nsec = ts.tv_nsec;
     } else {
-        sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+        sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
     }
-#else
-    sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-    nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
-#endif
 
     assure_size(out, 36);
     if (9 > out->opts->sec_prec) {
@@ -535,59 +535,39 @@ void oj_dump_xml_time(VALUE obj, Out out) {
     }
     if ((0 == nsec && !out->opts->sec_prec_set) || 0 == out->opts->sec_prec) {
         if (0 == tzsecs && rb_funcall2(obj, oj_utcq_id, 0, 0)) {
-            sprintf(buf,
-                    "%04d-%02d-%02dT%02d:%02d:%02dZ",
-                    ti.year,
-                    ti.mon,
-                    ti.day,
-                    ti.hour,
-                    ti.min,
-                    ti.sec);
-            oj_dump_cstr(buf, 20, 0, 0, out);
+            int len = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02dZ", ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec);
+            oj_dump_cstr(buf, len, 0, 0, out);
         } else {
-            sprintf(buf,
-                    "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
-                    ti.year,
-                    ti.mon,
-                    ti.day,
-                    ti.hour,
-                    ti.min,
-                    ti.sec,
-                    tzsign,
-                    tzhour,
-                    tzmin);
-            oj_dump_cstr(buf, 25, 0, 0, out);
+            int len = sprintf(buf,
+                              "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
+                              ti.year,
+                              ti.mon,
+                              ti.day,
+                              ti.hour,
+                              ti.min,
+                              ti.sec,
+                              tzsign,
+                              tzhour,
+                              tzmin);
+            oj_dump_cstr(buf, len, 0, 0, out);
         }
     } else if (0 == tzsecs && rb_funcall2(obj, oj_utcq_id, 0, 0)) {
         char format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ";
-        int  len        = 30;
+        int  len;
 
         if (9 > out->opts->sec_prec) {
             format[32] = '0' + out->opts->sec_prec;
-            len -= 9 - out->opts->sec_prec;
         }
-        sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, (long)nsec);
+        len = sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, (long)nsec);
         oj_dump_cstr(buf, len, 0, 0, out);
     } else {
         char format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ld%c%02d:%02d";
-        int  len        = 35;
+        int  len;
 
         if (9 > out->opts->sec_prec) {
             format[32] = '0' + out->opts->sec_prec;
-            len -= 9 - out->opts->sec_prec;
         }
-        sprintf(buf,
-                format,
-                ti.year,
-                ti.mon,
-                ti.day,
-                ti.hour,
-                ti.min,
-                ti.sec,
-                (long)nsec,
-                tzsign,
-                tzhour,
-                tzmin);
+        len = sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, (long)nsec, tzsign, tzhour, tzmin);
         oj_dump_cstr(buf, len, 0, 0, out);
     }
 }
@@ -598,12 +578,8 @@ void oj_dump_obj_to_json(VALUE obj, Options copts, Out out) {
 
 void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv) {
     if (0 == out->buf) {
-        out->buf = ALLOC_N(char, 4096);
-        // 1 less than end plus extra for possible errors
-        out->end       = out->buf + 4095 - BUFFER_EXTRA;
-        out->allocated = true;
+        oj_out_init(out);
     }
-    out->cur      = out->buf;
     out->circ_cnt = 0;
     out->opts     = copts;
     out->hash_cnt = 0;
@@ -638,38 +614,51 @@ void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int arg
 }
 
 void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
-    char        buf[4096];
     struct _out out;
     size_t      size;
-    FILE *      f;
+    FILE       *f;
     int         ok;
 
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - BUFFER_EXTRA;
-    out.allocated = false;
-    out.omit_nil  = copts->dump_opts.omit_nil;
+    oj_out_init(&out);
+
+    out.omit_nil = copts->dump_opts.omit_nil;
     oj_dump_obj_to_json(obj, copts, &out);
     size = out.cur - out.buf;
     if (0 == (f = fopen(path, "w"))) {
-        if (out.allocated) {
-            xfree(out.buf);
-        }
+        oj_out_free(&out);
         rb_raise(rb_eIOError, "%s", strerror(errno));
     }
     ok = (size == fwrite(out.buf, 1, size, f));
-    if (out.allocated) {
-        xfree(out.buf);
-    }
-    fclose(f);
+
+    oj_out_free(&out);
+
     if (!ok) {
         int err = ferror(f);
+        fclose(f);
 
         rb_raise(rb_eIOError, "Write failed. [%d:%s]", err, strerror(err));
     }
+    fclose(f);
+}
+
+#if !IS_WINDOWS
+static void write_ready(int fd) {
+    struct pollfd pp;
+    int           i;
+
+    pp.fd      = fd;
+    pp.events  = POLLERR | POLLOUT;
+    pp.revents = 0;
+    if (0 >= (i = poll(&pp, 1, 5000))) {
+        if (0 == i || EAGAIN == errno) {
+            rb_raise(rb_eIOError, "write timed out");
+        }
+        rb_raise(rb_eIOError, "write failed. %d %s.", errno, strerror(errno));
+    }
 }
+#endif
 
 void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
-    char        buf[4096];
     struct _out out;
     ssize_t     size;
     VALUE       clas = rb_obj_class(stream);
@@ -678,58 +667,62 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
     VALUE s;
 #endif
 
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - BUFFER_EXTRA;
-    out.allocated = false;
-    out.omit_nil  = copts->dump_opts.omit_nil;
+    oj_out_init(&out);
+
+    out.omit_nil = copts->dump_opts.omit_nil;
     oj_dump_obj_to_json(obj, copts, &out);
     size = out.cur - out.buf;
     if (oj_stringio_class == clas) {
         rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
 #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))) {
-        if (size != write(fd, out.buf, size)) {
-            if (out.allocated) {
-                xfree(out.buf);
+    } else if (rb_respond_to(stream, oj_fileno_id) && Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
+               0 != (fd = FIX2INT(s))) {
+        ssize_t cnt;
+        ssize_t total = 0;
+
+        while (true) {
+            if (0 > (cnt = write(fd, out.buf + total, size - total))) {
+                if (EAGAIN != errno) {
+                    rb_raise(rb_eIOError, "write failed. %d %s.", errno, strerror(errno));
+                    break;
+                }
             }
-            rb_raise(rb_eIOError, "Write failed. [%d:%s]", errno, strerror(errno));
+            total += cnt;
+            if (size <= total) {
+                // Completed
+                break;
+            }
+            write_ready(fd);
         }
 #endif
     } else if (rb_respond_to(stream, oj_write_id)) {
         rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
     } else {
-        if (out.allocated) {
-            xfree(out.buf);
-        }
+        oj_out_free(&out);
         rb_raise(rb_eArgError, "to_stream() expected an IO Object.");
     }
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+    oj_out_free(&out);
 }
 
 void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
-    rb_encoding *enc = rb_to_encoding(rb_obj_encoding(obj));
+    int idx = RB_ENCODING_GET(obj);
 
-    if (rb_utf8_encoding() != enc) {
-        obj = rb_str_conv_enc(obj, enc, rb_utf8_encoding());
+    if (oj_utf8_encoding_index != idx) {
+        rb_encoding *enc = rb_enc_from_index(idx);
+        obj              = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&obj), (int)RSTRING_LEN(obj), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    // This causes a memory leak in 2.5.1. Maybe in other versions as well.
-    // const char	*sym = rb_id2name(SYM2ID(obj));
-
-    volatile VALUE s = rb_sym_to_s(obj);
+    volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&s), (int)RSTRING_LEN(s), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 0, 0, out);
 }
 
 static void debug_raise(const char *orig, size_t cnt, int line) {
     char        buf[1024];
-    char *      b     = buf;
+    char       *b     = buf;
     const char *s     = orig;
     const char *s_end = s + cnt;
 
@@ -745,8 +738,11 @@ static void debug_raise(const char *orig, size_t cnt, int line) {
 
 void oj_dump_raw_json(VALUE obj, int depth, Out out) {
     if (oj_string_writer_class == rb_obj_class(obj)) {
-        StrWriter sw  = (StrWriter)DATA_PTR(obj);
-        size_t    len = sw->out.cur - sw->out.buf;
+        StrWriter sw;
+        size_t    len;
+
+        sw  = oj_str_writer_unwrap(obj);
+        len = sw->out.cur - sw->out.buf;
 
         if (0 < len) {
             len--;
@@ -755,22 +751,19 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
     } else {
         volatile VALUE jv;
 
-        if (Yes == out->opts->trace) {
-            oj_trace("raw_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyIn);
-        }
+        TRACE(out->opts->trace, "raw_json", obj, depth + 1, TraceRubyIn);
         jv = rb_funcall(obj, oj_raw_json_id, 2, RB_INT2NUM(depth), RB_INT2NUM(out->indent));
-        if (Yes == out->opts->trace) {
-            oj_trace("raw_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
-        }
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&jv), (size_t)RSTRING_LEN(jv), out);
+        TRACE(out->opts->trace, "raw_json", obj, depth + 1, TraceRubyOut);
+        oj_dump_raw(RSTRING_PTR(jv), (size_t)RSTRING_LEN(jv), out);
     }
 }
 
 void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out out) {
     size_t      size;
-    char *      cmap;
-    const char *orig   = str;
-    bool        has_hi = false;
+    char       *cmap;
+    const char *orig                  = str;
+    bool        has_hi                = false;
+    bool        do_unicode_validation = false;
 
     switch (out->opts->escape_mode) {
     case NLEsc:
@@ -781,13 +774,19 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         cmap = ascii_friendly_chars;
         size = ascii_friendly_size((uint8_t *)str, cnt);
         break;
+    case SlashEsc:
+        has_hi = true;
+        cmap   = slash_friendly_chars;
+        size   = slash_friendly_size((uint8_t *)str, cnt);
+        break;
     case XSSEsc:
         cmap = xss_friendly_chars;
         size = xss_friendly_size((uint8_t *)str, cnt);
         break;
     case JXEsc:
-        cmap = hixss_friendly_chars;
-        size = hixss_friendly_size((uint8_t *)str, cnt);
+        cmap                  = hixss_friendly_chars;
+        size                  = hixss_friendly_size((uint8_t *)str, cnt);
+        do_unicode_validation = true;
         break;
     case RailsXEsc: {
         long sz;
@@ -800,12 +799,22 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         } else {
             size = (size_t)sz;
         }
+        do_unicode_validation = true;
         break;
     }
-    case RailsEsc:
+    case RailsEsc: {
+        long sz;
         cmap = rails_friendly_chars;
-        size = rails_friendly_size((uint8_t *)str, cnt);
+        sz   = rails_friendly_size((uint8_t *)str, cnt);
+        if (sz < 0) {
+            has_hi = true;
+            size   = (size_t)-sz;
+        } else {
+            size = (size_t)sz;
+        }
+        do_unicode_validation = true;
         break;
+    }
     case JSONEsc:
     default: cmap = hibit_friendly_chars; size = hibit_friendly_size((uint8_t *)str, cnt);
     }
@@ -813,10 +822,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
     *out->cur++ = '"';
 
     if (escape1) {
-        *out->cur++ = '\\';
-        *out->cur++ = 'u';
-        *out->cur++ = '0';
-        *out->cur++ = '0';
+        APPEND_CHARS(out->cur, "\\u00", 4);
         dump_hex((uint8_t)*str, out);
         cnt--;
         size--;
@@ -827,9 +833,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         if (is_sym) {
             *out->cur++ = ':';
         }
-        for (; '\0' != *str; str++) {
-            *out->cur++ = *str;
-        }
+        APPEND_CHARS(out->cur, str, cnt);
         *out->cur++ = '"';
     } else {
         const char *end         = str + cnt;
@@ -841,8 +845,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         for (; str < end; str++) {
             switch (cmap[(uint8_t)*str]) {
             case '1':
-                if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-                    check_start <= str) {
+                if (do_unicode_validation && check_start <= str) {
                     if (0 != (0x80 & (uint8_t)*str)) {
                         if (0xC0 == (0xC0 & (uint8_t)*str)) {
                             check_start = check_unicode(str, end, orig);
@@ -866,11 +869,8 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                 }
                 break;
             case '3':  // Unicode
-                if (0xe2 == (uint8_t)*str &&
-                    (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-                    2 <= end - str) {
-                    if (0x80 == (uint8_t)str[1] &&
-                        (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
+                if (0xe2 == (uint8_t)*str && do_unicode_validation && 2 <= end - str) {
+                    if (0x80 == (uint8_t)str[1] && (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
                         str = dump_unicode(str, end, out, orig);
                     } else {
                         check_start = check_unicode(str, end, orig);
@@ -882,17 +882,14 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                 break;
             case '6':  // control characters
                 if (*(uint8_t *)str < 0x80) {
-                    *out->cur++ = '\\';
-                    *out->cur++ = 'u';
-                    *out->cur++ = '0';
-                    *out->cur++ = '0';
+                    if (0 == (uint8_t)*str && out->opts->dump_opts.omit_null_byte) {
+                        break;
+                    }
+                    APPEND_CHARS(out->cur, "\\u00", 4);
                     dump_hex((uint8_t)*str, out);
                 } else {
-                    if (0xe2 == (uint8_t)*str &&
-                        (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-                        2 <= end - str) {
-                        if (0x80 == (uint8_t)str[1] &&
-                            (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
+                    if (0xe2 == (uint8_t)*str && do_unicode_validation && 2 <= end - str) {
+                        if (0x80 == (uint8_t)str[1] && (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
                             str = dump_unicode(str, end, out, orig);
                         } else {
                             check_start = check_unicode(str, end, orig);
@@ -908,8 +905,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         }
         *out->cur++ = '"';
     }
-    if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-        0 < str - orig && 0 != (0x80 & *(str - 1))) {
+    if (do_unicode_validation && 0 < str - orig && 0 != (0x80 & *(str - 1))) {
         uint8_t c = (uint8_t) * (str - 1);
         int     i;
         int     scnt = (int)(str - orig);
@@ -959,31 +955,43 @@ void oj_dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 void oj_dump_obj_to_s(VALUE obj, Out out) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_raw(const char *str, size_t cnt, Out out) {
     assure_size(out, cnt + 10);
-    memcpy(out->cur, str, cnt);
-    out->cur += cnt;
+    APPEND_CHARS(out->cur, str, cnt);
     *out->cur = '\0';
 }
 
+void oj_out_init(Out out) {
+    out->buf       = out->stack_buffer;
+    out->cur       = out->buf;
+    out->end       = out->buf + sizeof(out->stack_buffer) - BUFFER_EXTRA;
+    out->allocated = false;
+}
+
+void oj_out_free(Out out) {
+    if (out->allocated) {
+        OJ_R_FREE(out->buf);  // TBD
+    }
+}
+
 void oj_grow_out(Out out, size_t len) {
     size_t size = out->end - out->buf;
     long   pos  = out->cur - out->buf;
-    char * buf  = out->buf;
+    char  *buf  = out->buf;
 
     size *= 2;
     if (size <= len * 2 + pos) {
         size += len;
     }
     if (out->allocated) {
-        REALLOC_N(buf, char, (size + BUFFER_EXTRA));
+        OJ_R_REALLOC_N(buf, char, (size + BUFFER_EXTRA));
     } else {
-        buf            = ALLOC_N(char, (size + BUFFER_EXTRA));
+        buf            = OJ_R_ALLOC_N(char, (size + BUFFER_EXTRA));
         out->allocated = true;
         memcpy(buf, out->buf, out->end - out->buf + BUFFER_EXTRA);
     }
@@ -997,37 +1005,62 @@ void oj_grow_out(Out out, size_t len) {
 
 void oj_dump_nil(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 4);
-    *out->cur++ = 'n';
-    *out->cur++ = 'u';
-    *out->cur++ = 'l';
-    *out->cur++ = 'l';
-    *out->cur   = '\0';
+    APPEND_CHARS(out->cur, "null", 4);
+    *out->cur = '\0';
 }
 
 void oj_dump_true(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 4);
-    *out->cur++ = 't';
-    *out->cur++ = 'r';
-    *out->cur++ = 'u';
-    *out->cur++ = 'e';
-    *out->cur   = '\0';
+    APPEND_CHARS(out->cur, "true", 4);
+    *out->cur = '\0';
 }
 
 void oj_dump_false(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 5);
-    *out->cur++ = 'f';
-    *out->cur++ = 'a';
-    *out->cur++ = 'l';
-    *out->cur++ = 's';
-    *out->cur++ = 'e';
-    *out->cur   = '\0';
+    APPEND_CHARS(out->cur, "false", 5);
+    *out->cur = '\0';
+}
+
+static const char digits_table[] = "\
+00010203040506070809\
+10111213141516171819\
+20212223242526272829\
+30313233343536373839\
+40414243444546474849\
+50515253545556575859\
+60616263646566676869\
+70717273747576777879\
+80818283848586878889\
+90919293949596979899";
+
+char *oj_longlong_to_string(long long num, bool negative, char *buf) {
+    while (100 <= num) {
+        unsigned idx = num % 100 * 2;
+        *buf--       = digits_table[idx + 1];
+        *buf--       = digits_table[idx];
+        num /= 100;
+    }
+    if (num < 10) {
+        *buf-- = num + '0';
+    } else {
+        *buf-- = digits_table[num * 2 + 1];
+        *buf-- = digits_table[num * 2];
+    }
+
+    if (negative) {
+        *buf = '-';
+    } else {
+        buf++;
+    }
+    return buf;
 }
 
 void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
     char      buf[32];
-    char *    b              = buf + sizeof(buf) - 1;
-    long long num            = rb_num2ll(obj);
-    int       neg            = 0;
+    char     *b              = buf + sizeof(buf) - 1;
+    long long num            = NUM2LL(obj);
+    bool      neg            = false;
+    size_t    cnt            = 0;
     bool      dump_as_string = false;
 
     if (out->opts->int_range_max != 0 && out->opts->int_range_min != 0 &&
@@ -1035,7 +1068,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         dump_as_string = true;
     }
     if (0 > num) {
-        neg = 1;
+        neg = true;
         num = -num;
     }
     *b-- = '\0';
@@ -1044,24 +1077,16 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         *b-- = '"';
     }
     if (0 < num) {
-        for (; 0 < num; num /= 10, b--) {
-            *b = (num % 10) + '0';
-        }
-        if (neg) {
-            *b = '-';
-        } else {
-            b++;
-        }
+        b = oj_longlong_to_string(num, neg, b);
     } else {
         *b = '0';
     }
     if (dump_as_string) {
         *--b = '"';
     }
-    assure_size(out, (sizeof(buf) - (b - buf)));
-    for (; '\0' != *b; b++) {
-        *out->cur++ = *b;
-    }
+    cnt = sizeof(buf) - (b - buf) - 1;
+    assure_size(out, cnt);
+    APPEND_CHARS(out->cur, b, cnt);
     *out->cur = '\0';
 }
 
@@ -1070,16 +1095,14 @@ void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     int            cnt            = (int)RSTRING_LEN(rs);
     bool           dump_as_string = false;
 
-    if (out->opts->int_range_max != 0 ||
-        out->opts->int_range_min != 0) {  // Bignum cannot be inside of Fixnum range
+    if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {  // Bignum cannot be inside of Fixnum range
         dump_as_string = true;
         assure_size(out, cnt + 2);
         *out->cur++ = '"';
     } else {
         assure_size(out, cnt);
     }
-    memcpy(out->cur, rb_string_value_ptr((VALUE *)&rs), cnt);
-    out->cur += cnt;
+    APPEND_CHARS(out->cur, RSTRING_PTR(rs), cnt);
     if (dump_as_string) {
         *out->cur++ = '"';
     }
@@ -1089,7 +1112,7 @@ void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
 // Removed dependencies on math due to problems with CentOS 5.4.
 void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
-    char * b;
+    char  *b;
     double d   = rb_num2dbl(obj);
     int    cnt = 0;
 
@@ -1168,7 +1191,7 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     } else if (isnan(d)) {
         if (ObjectMode == out->opts->mode) {
             strcpy(buf, nan_val);
-            cnt = sizeof(ninf_val) - 1;
+            cnt = sizeof(nan_val) - 1;
         } else {
             NanDump nd = out->opts->dump_opts.nan_dump;
 
@@ -1200,21 +1223,19 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     } else if (d == (double)(long long int)d) {
         cnt = snprintf(buf, sizeof(buf), "%.1f", d);
     } else if (0 == out->opts->float_prec) {
-        volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+        volatile VALUE rstr = oj_safe_string_convert(obj);
 
         cnt = (int)RSTRING_LEN(rstr);
         if ((int)sizeof(buf) <= cnt) {
             cnt = sizeof(buf) - 1;
         }
-        strncpy(buf, rb_string_value_ptr((VALUE *)&rstr), cnt);
+        memcpy(buf, RSTRING_PTR(rstr), cnt);
         buf[cnt] = '\0';
     } else {
         cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
     }
     assure_size(out, cnt);
-    for (b = buf; '\0' != *b; b++) {
-        *out->cur++ = *b;
-    }
+    APPEND_CHARS(out->cur, buf, cnt);
     *out->cur = '\0';
 }
 
@@ -1224,24 +1245,10 @@ int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char
     // Round off issues at 16 significant digits so check for obvious ones of
     // 0001 and 9999.
     if (17 <= cnt && (0 == strcmp("0001", buf + cnt - 4) || 0 == strcmp("9999", buf + cnt - 4))) {
-        volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+        volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        strcpy(buf, rb_string_value_ptr((VALUE *)&rstr));
+        strcpy(buf, RSTRING_PTR(rstr));
         cnt = (int)RSTRING_LEN(rstr);
     }
     return cnt;
 }
-
-bool oj_dump_ignore(Options opts, VALUE obj) {
-    if (NULL != opts->ignore && (ObjectMode == opts->mode || CustomMode == opts->mode)) {
-        VALUE *vp   = opts->ignore;
-        VALUE  clas = rb_obj_class(obj);
-
-        for (; Qnil != *vp; vp++) {
-            if (clas == *vp) {
-                return true;
-            }
-        }
-    }
-    return false;
-}