oj 3.11.5 → 3.16.5

data/ext/oj/parse.c

@@ -12,14 +12,19 @@
 
 #include "buf.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.h"
 #include "rxclass.h"
 #include "val_stack.h"
 
+#ifdef OJ_USE_SSE4_2
+#include <nmmintrin.h>
+#endif
+
 // Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
 #define OJ_INFINITY (1.0 / 0.0)
 
-//#define EXP_MAX		1023
+// #define EXP_MAX		1023
 #define EXP_MAX 100000
 #define DEC_MAX 15
 
@@ -44,11 +49,7 @@ static void skip_comment(ParseInfo pi) {
                 pi->cur += 2;
                 return;
             } else if (pi->end <= pi->cur) {
-                oj_set_error_at(pi,
-                                oj_parse_error_class,
-                                __FILE__,
-                                __LINE__,
-                                "comment not terminated");
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "comment not terminated");
                 return;
             }
         }
@@ -81,9 +82,8 @@ static void add_value(ParseInfo pi, VALUE rval) {
             break;
         case NEXT_HASH_VALUE:
             pi->hash_set_value(pi, parent, rval);
-            if (0 != parent->key && 0 < parent->klen &&
-                (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+            if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -183,6 +183,46 @@ static void unicode_to_chars(ParseInfo pi, Buf buf, uint32_t code) {
     }
 }
 
+static inline const char *scan_string_noSIMD(const char *str, const char *end) {
+    for (; '"' != *str; str++) {
+        if (end <= str || '\0' == *str || '\\' == *str) {
+            break;
+        }
+    }
+    return str;
+}
+
+#ifdef OJ_USE_SSE4_2
+static inline const char *scan_string_SIMD(const char *str, const char *end) {
+    static const char chars[16] = "\x00\\\"";
+    const __m128i     terminate = _mm_loadu_si128((const __m128i *)&chars[0]);
+    const char       *_end      = (const char *)(end - 16);
+
+    for (; str <= _end; str += 16) {
+        const __m128i string = _mm_loadu_si128((const __m128i *)str);
+        const int     r      = _mm_cmpestri(terminate,
+                                   3,
+                                   string,
+                                   16,
+                                   _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (r != 16) {
+            str = (char *)(str + r);
+            return str;
+        }
+    }
+
+    return scan_string_noSIMD(str, end);
+}
+#endif
+
+static const char *(*scan_func)(const char *str, const char *end) = scan_string_noSIMD;
+
+void oj_scanner_init(void) {
+#ifdef OJ_USE_SSE4_2
+    scan_func = scan_string_SIMD;
+#endif
+}
+
 // entered at /
 static void read_escaped_str(ParseInfo pi, const char *start) {
     struct _buf buf;
@@ -192,19 +232,20 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
     Val         parent = stack_peek(&pi->stack);
 
     buf_init(&buf);
-    if (0 < cnt) {
-        buf_append_string(&buf, start, cnt);
-    }
-    for (s = pi->cur; '"' != *s; s++) {
-        if (s >= pi->end) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "quoted string not terminated");
+    buf_append_string(&buf, start, cnt);
+
+    for (s = pi->cur; '"' != *s;) {
+        const char *scanned = scan_func(s, pi->end);
+        if (scanned >= pi->end || '\0' == *scanned) {
+            // if (scanned >= pi->end) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
             buf_cleanup(&buf);
             return;
-        } else if ('\\' == *s) {
+        }
+        buf_append_string(&buf, s, (size_t)(scanned - s));
+        s = scanned;
+
+        if ('\\' == *s) {
             s++;
             switch (*s) {
             case 'n': buf_append(&buf, '\n'); break;
@@ -234,11 +275,7 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
                             break;
                         }
                         pi->cur = s;
-                        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;
                     }
@@ -265,16 +302,11 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
                     break;
                 }
                 pi->cur = s;
-                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;
             }
-        } else {
-            buf_append(&buf, *s);
+            s++;
         }
     }
     if (0 == parent) {
@@ -290,7 +322,7 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
         case NEXT_HASH_KEY:
             if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
                 parent->klen = buf_len(&buf);
-                parent->key  = malloc(parent->klen + 1);
+                parent->key  = OJ_MALLOC(parent->klen + 1);
                 memcpy((char *)parent->key, buf.head, parent->klen);
                 *(char *)(parent->key + parent->klen) = '\0';
             } else {
@@ -302,9 +334,8 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
             break;
         case NEXT_HASH_VALUE:
             pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), start);
-            if (0 != parent->key && 0 < parent->klen &&
-                (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+            if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -331,22 +362,20 @@ static void read_str(ParseInfo pi) {
     const char *str    = pi->cur;
     Val         parent = stack_peek(&pi->stack);
 
-    for (; '"' != *pi->cur; pi->cur++) {
-        if (pi->end <= pi->cur) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "quoted string not terminated");
-            return;
-        } else if ('\0' == *pi->cur) {
-            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "NULL byte in string");
-            return;
-        } else if ('\\' == *pi->cur) {
-            read_escaped_str(pi, str);
-            return;
-        }
+    pi->cur = scan_func(pi->cur, pi->end);
+    if (RB_UNLIKELY(pi->end <= pi->cur)) {
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
+        return;
+    }
+    if (RB_UNLIKELY('\0' == *pi->cur)) {
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "NULL byte in string");
+        return;
+    }
+    if ('\\' == *pi->cur) {
+        read_escaped_str(pi, str);
+        return;
     }
+
     if (0 == parent) {  // simple add
         pi->add_cstr(pi, str, pi->cur - str, str);
     } else {
@@ -370,9 +399,8 @@ static void read_str(ParseInfo pi) {
             break;
         case NEXT_HASH_VALUE:
             pi->hash_set_cstr(pi, parent, str, pi->cur - str, str);
-            if (0 != parent->key && 0 < parent->klen &&
-                (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+            if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -398,6 +426,7 @@ static void read_num(ParseInfo pi) {
     struct _numInfo ni;
     Val             parent = stack_peek(&pi->stack);
 
+    ni.pi       = pi;
     ni.str      = pi->cur;
     ni.i        = 0;
     ni.num      = 0;
@@ -414,7 +443,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;
     }
@@ -424,33 +453,21 @@ static void read_num(ParseInfo pi) {
         ni.neg = 1;
     } else if ('+' == *pi->cur) {
         if (StrictMode == pi->options.mode) {
-            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;
         }
         pi->cur++;
     }
     if ('I' == *pi->cur) {
         if (No == pi->options.allow_nan || 0 != strncmp("Infinity", pi->cur, 8)) {
-            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;
         }
         pi->cur += 8;
         ni.infinity = 1;
     } else if ('N' == *pi->cur || 'n' == *pi->cur) {
         if ('a' != pi->cur[1] || ('N' != pi->cur[2] && 'n' != pi->cur[2])) {
-            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;
         }
         pi->cur += 3;
@@ -459,37 +476,31 @@ static void read_num(ParseInfo pi) {
         int  dec_cnt = 0;
         bool zero1   = false;
 
+        // Skip leading zeros.
+        for (; '0' == *pi->cur; pi->cur++) {
+            zero1 = true;
+        }
+
         for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
-            if (0 == ni.i && '0' == *pi->cur) {
-                zero1 = true;
-            }
-            if (0 < ni.i) {
-                dec_cnt++;
-            }
-            if (!ni.big) {
-                int d = (*pi->cur - '0');
+            int d = (*pi->cur - '0');
 
-                if (0 < d) {
-                    if (zero1 && CompatMode == pi->options.mode) {
-                        oj_set_error_at(pi,
-                                        oj_parse_error_class,
-                                        __FILE__,
-                                        __LINE__,
-                                        "not a number");
-                        return;
-                    }
-                    zero1 = false;
-                }
-                ni.i = ni.i * 10 + d;
-                if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
-                    ni.big = 1;
-                }
+            if (RB_LIKELY(0 != ni.i)) {
+                dec_cnt++;
             }
+            ni.i = ni.i * 10 + d;
+        }
+        if (RB_UNLIKELY(0 != ni.i && zero1 && CompatMode == pi->options.mode)) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
+            return;
         }
+        if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
+            ni.big = true;
+        }
+
         if ('.' == *pi->cur) {
             pi->cur++;
             // A trailing . is not a valid decimal but if encountered allow it
-            // except when mimicing the JSON gem or in strict mode.
+            // except when mimicking the JSON gem or in strict mode.
             if (StrictMode == pi->options.mode || CompatMode == pi->options.mode) {
                 int pos = (int)(pi->cur - ni.str);
 
@@ -505,25 +516,20 @@ static void read_num(ParseInfo pi) {
             for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
                 int d = (*pi->cur - '0');
 
-                if (0 < ni.num || 0 < ni.i) {
+                if (RB_LIKELY(0 != ni.num || 0 != ni.i)) {
                     dec_cnt++;
                 }
-                if (INT64_MAX <= ni.div) {
-                    if (!ni.no_big) {
-                        ni.big = true;
-                    }
-                } else {
-                    ni.num = ni.num * 10 + d;
-                    ni.div *= 10;
-                    ni.di++;
-                    if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
-                        if (!ni.no_big) {
-                            ni.big = true;
-                        }
-                    }
-                }
+                ni.num = ni.num * 10 + d;
+                ni.div *= 10;
+                ni.di++;
             }
         }
+        if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
+            if (!ni.no_big) {
+                ni.big = true;
+            }
+        }
+
         if ('e' == *pi->cur || 'E' == *pi->cur) {
             int eneg = 0;
 
@@ -576,9 +582,8 @@ static void read_num(ParseInfo pi) {
             break;
         case NEXT_HASH_VALUE:
             pi->hash_set_num(pi, parent, &ni);
-            if (0 != parent->key && 0 < parent->klen &&
-                (parent->key < pi->json || pi->cur < parent->key)) {
-                xfree((char *)parent->key);
+            if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
+                OJ_R_FREE((char *)parent->key);
                 parent->key = 0;
             }
             parent->next = NEXT_HASH_COMMA;
@@ -596,7 +601,7 @@ static void read_num(ParseInfo pi) {
 }
 
 static void array_start(ParseInfo pi) {
-    volatile VALUE v = pi->start_array(pi);
+    VALUE v = pi->start_array(pi);
 
     stack_push(&pi->stack, v, NEXT_ARRAY_NEW);
 }
@@ -620,13 +625,13 @@ static void array_end(ParseInfo pi) {
 }
 
 static void hash_start(ParseInfo pi) {
-    volatile VALUE v = pi->start_hash(pi);
+    VALUE v = pi->start_hash(pi);
 
     stack_push(&pi->stack, v, NEXT_HASH_NEW);
 }
 
 static void hash_end(ParseInfo pi) {
-    volatile Val hash = stack_peek(&pi->stack);
+    Val hash = stack_peek(&pi->stack);
 
     // leave hash on stack until just before
     if (0 == hash) {
@@ -705,17 +710,10 @@ void oj_parse2(ParseInfo pi) {
         case '[': array_start(pi); break;
         case ']': array_end(pi); break;
         case ',': comma(pi); break;
-        case '"':
-            read_str(pi);
-            break;
-            // case '+':
+        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--;
@@ -741,11 +739,7 @@ void oj_parse2(ParseInfo pi) {
                 pi->cur--;
                 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");
             }
             break;
         case 't': read_true(pi); break;
@@ -765,9 +759,7 @@ void oj_parse2(ParseInfo pi) {
             }
             break;
         case '\0': pi->cur--; return;
-        default:
-            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
-            return;
+        default: oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character"); return;
         }
         if (err_has(&pi->err)) {
             return;
@@ -804,16 +796,15 @@ static VALUE parse_big_decimal(VALUE str) {
 }
 
 static long double exp_plus[] = {
-    1.0,    1.0e1,  1.0e2,  1.0e3,  1.0e4,  1.0e5,  1.0e6,  1.0e7,  1.0e8,  1.0e9,
-    1.0e10, 1.0e11, 1.0e12, 1.0e13, 1.0e14, 1.0e15, 1.0e16, 1.0e17, 1.0e18, 1.0e19,
-    1.0e20, 1.0e21, 1.0e22, 1.0e23, 1.0e24, 1.0e25, 1.0e26, 1.0e27, 1.0e28, 1.0e29,
-    1.0e30, 1.0e31, 1.0e32, 1.0e33, 1.0e34, 1.0e35, 1.0e36, 1.0e37, 1.0e38, 1.0e39,
-    1.0e40, 1.0e41, 1.0e42, 1.0e43, 1.0e44, 1.0e45, 1.0e46, 1.0e47, 1.0e48, 1.0e49,
+    1.0,    1.0e1,  1.0e2,  1.0e3,  1.0e4,  1.0e5,  1.0e6,  1.0e7,  1.0e8,  1.0e9,  1.0e10, 1.0e11, 1.0e12,
+    1.0e13, 1.0e14, 1.0e15, 1.0e16, 1.0e17, 1.0e18, 1.0e19, 1.0e20, 1.0e21, 1.0e22, 1.0e23, 1.0e24, 1.0e25,
+    1.0e26, 1.0e27, 1.0e28, 1.0e29, 1.0e30, 1.0e31, 1.0e32, 1.0e33, 1.0e34, 1.0e35, 1.0e36, 1.0e37, 1.0e38,
+    1.0e39, 1.0e40, 1.0e41, 1.0e42, 1.0e43, 1.0e44, 1.0e45, 1.0e46, 1.0e47, 1.0e48, 1.0e49,
 };
 
 VALUE
 oj_num_as_value(NumInfo ni) {
-    volatile VALUE rnum = Qnil;
+    VALUE rnum = Qnil;
 
     if (ni->infinity) {
         if (ni->neg) {
@@ -832,12 +823,12 @@ oj_num_as_value(NumInfo ni) {
                 buf[ni->len] = '\0';
                 rnum         = rb_cstr_to_inum(buf, 10, 0);
             } else {
-                char *buf = ALLOC_N(char, ni->len + 1);
+                char *buf = OJ_R_ALLOC_N(char, ni->len + 1);
 
                 memcpy(buf, ni->str, ni->len);
                 buf[ni->len] = '\0';
                 rnum         = rb_cstr_to_inum(buf, 10, 0);
-                xfree(buf);
+                OJ_R_FREE(buf);
             }
         } else {
             if (ni->neg) {
@@ -848,7 +839,7 @@ oj_num_as_value(NumInfo ni) {
         }
     } else {  // decimal
         if (ni->big) {
-            volatile VALUE bd = rb_str_new(ni->str, ni->len);
+            VALUE bd = rb_str_new(ni->str, ni->len);
 
             rnum = rb_rescue2(parse_big_decimal, bd, rescue_big_decimal, bd, rb_eException, 0);
             if (ni->no_big) {
@@ -876,15 +867,19 @@ oj_num_as_value(NumInfo ni) {
             }
             rnum = rb_float_new((double)ld);
         } else if (RubyDec == ni->bigdec_load) {
-            volatile VALUE sv = rb_str_new(ni->str, ni->len);
+            VALUE sv = rb_str_new(ni->str, ni->len);
 
             rnum = rb_funcall(sv, rb_intern("to_f"), 0);
         } else {
-            char * end;
+            char  *end;
             double d = strtod(ni->str, &end);
 
             if ((long)ni->len != (long)(end - ni->str)) {
-                rb_raise(oj_parse_error_class, "Invalid float");
+                if (Qnil == ni->pi->err_class) {
+                    rb_raise(oj_parse_error_class, "Invalid float");
+                } else {
+                    rb_raise(ni->pi->err_class, "Invalid float");
+                }
             }
             rnum = rb_float_new(d);
         }
@@ -892,21 +887,24 @@ oj_num_as_value(NumInfo ni) {
     return rnum;
 }
 
-void oj_set_error_at(ParseInfo   pi,
-                     VALUE       err_clas,
-                     const char *file,
-                     int         line,
-                     const char *format,
-                     ...) {
+void oj_set_error_at(ParseInfo pi, VALUE err_clas, const char *file, int line, const char *format, ...) {
     va_list ap;
     char    msg[256];
-    char *  p   = msg;
-    char *  end = p + sizeof(msg) - 2;
-    char *  start;
+    char   *p   = msg;
+    char   *end = p + sizeof(msg) - 2;
+    char   *start;
     Val     vp;
+    int     mlen;
 
     va_start(ap, format);
-    p += vsnprintf(msg, sizeof(msg) - 1, format, ap);
+    mlen = vsnprintf(msg, sizeof(msg) - 1, format, ap);
+    if (0 < mlen) {
+        if (sizeof(msg) - 2 < (size_t)mlen) {
+            p = end - 2;
+        } else {
+            p += mlen;
+        }
+    }
     va_end(ap);
     pi->err.clas = err_clas;
     if (p + 3 < end) {
@@ -942,14 +940,7 @@ void oj_set_error_at(ParseInfo   pi,
     }
     *p = '\0';
     if (0 == pi->json) {
-        oj_err_set(&pi->err,
-                   err_clas,
-                   "%s at line %d, column %d [%s:%d]",
-                   msg,
-                   pi->rd.line,
-                   pi->rd.col,
-                   file,
-                   line);
+        oj_err_set(&pi->err, err_clas, "%s at line %d, column %d [%s:%d]", msg, pi->rd.line, pi->rd.col, file, line);
     } else {
         _oj_err_set_with_location(&pi->err, err_clas, msg, pi->json, pi->cur - 1, file, line);
     }
@@ -963,24 +954,25 @@ static VALUE protect_parse(VALUE pip) {
 
 extern int oj_utf8_index;
 
-static void oj_pi_set_input_str(ParseInfo pi, volatile VALUE *inputp) {
-    rb_encoding *enc = rb_to_encoding(rb_obj_encoding(*inputp));
+static void oj_pi_set_input_str(ParseInfo pi, VALUE *inputp) {
+    int idx = RB_ENCODING_GET(*inputp);
 
-    if (rb_utf8_encoding() != enc) {
-        *inputp = rb_str_conv_enc(*inputp, enc, rb_utf8_encoding());
+    if (oj_utf8_encoding_index != idx) {
+        rb_encoding *enc = rb_enc_from_index(idx);
+        *inputp          = rb_str_conv_enc(*inputp, enc, oj_utf8_encoding);
     }
-    pi->json = rb_string_value_ptr((VALUE *)inputp);
+    pi->json = RSTRING_PTR(*inputp);
     pi->end  = pi->json + RSTRING_LEN(*inputp);
 }
 
 VALUE
 oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk) {
-    char *         buf = 0;
-    volatile VALUE input;
-    volatile VALUE wrapped_stack;
-    volatile VALUE result    = Qnil;
-    int            line      = 0;
-    int            free_json = 0;
+    char *buf = 0;
+    VALUE input;
+    VALUE wrapped_stack;
+    VALUE result    = Qnil;
+    int   line      = 0;
+    int   free_json = 0;
 
     if (argc < 1) {
         rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
@@ -1016,8 +1008,8 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             rb_raise(rb_eTypeError, "Nil is not a valid JSON source.");
         }
     } else {
-        VALUE          clas = rb_obj_class(input);
-        volatile VALUE s;
+        VALUE clas = rb_obj_class(input);
+        VALUE s;
 
         if (oj_stringio_class == clas) {
             s = rb_funcall2(input, oj_string_id, 0, 0);
@@ -1029,19 +1021,18 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             size_t  len = lseek(fd, 0, SEEK_END);
 
             lseek(fd, 0, SEEK_SET);
-            buf      = ALLOC_N(char, len + 1);
+            buf      = OJ_R_ALLOC_N(char, len + 1);
             pi->json = buf;
             pi->end  = buf + len;
             if (0 >= (cnt = read(fd, (char *)pi->json, len)) || cnt != (ssize_t)len) {
                 if (0 != buf) {
-                    xfree(buf);
+                    OJ_R_FREE(buf);
                 }
                 rb_raise(rb_eIOError, "failed to read from IO Object.");
             }
             ((char *)pi->json)[len] = '\0';
             /* skip UTF-8 BOM if present */
-            if (0xEF == (uint8_t)*pi->json && 0xBB == (uint8_t)pi->json[1] &&
-                0xBF == (uint8_t)pi->json[2]) {
+            if (0xEF == (uint8_t)*pi->json && 0xBB == (uint8_t)pi->json[1] && 0xBF == (uint8_t)pi->json[2]) {
                 pi->cur += 3;
             }
 #endif
@@ -1067,8 +1058,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
     wrapped_stack = oj_stack_init(&pi->stack);
     rb_protect(protect_parse, (VALUE)pi, &line);
     if (Qundef == pi->stack.head->val && !empty_ok(&pi->options)) {
-        if (No == pi->options.nilnil ||
-            (CompatMode == pi->options.mode && 0 < pi->cur - pi->json)) {
+        if (No == pi->options.nilnil || (CompatMode == pi->options.mode && 0 < pi->cur - pi->json)) {
             oj_set_error_at(pi, oj_json_parser_error_class, __FILE__, __LINE__, "Empty input");
         }
     }
@@ -1096,9 +1086,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             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:
@@ -1116,9 +1104,9 @@ CLEANUP:
         oj_circ_array_free(pi->circ_array);
     }
     if (0 != buf) {
-        xfree(buf);
+        OJ_R_FREE(buf);
     } else if (free_json) {
-        xfree(json);
+        OJ_R_FREE(json);
     }
     stack_cleanup(&pi->stack);
     if (pi->str_rx.head != oj_default_options.str_rx.head) {
@@ -1129,7 +1117,7 @@ CLEANUP:
         if (Qnil != pi->err_class) {
             pi->err.clas = pi->err_class;
         }
-        if (CompatMode == pi->options.mode && Yes != pi->options.safe) {
+        if ((CompatMode == pi->options.mode || RailsMode == pi->options.mode) && Yes != pi->options.safe) {
             // The json gem requires the error message be UTF-8 encoded. In
             // additional the complete JSON source must be returned. There
             // does not seem to be a size limit.