oj 3.13.23 → 3.16.10

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,9 +183,19 @@ static void unicode_to_chars(ParseInfo pi, Buf buf, uint32_t code) {
     }
 }
 
+static const unsigned char end_of_scan_string[] = {
+    // Filled 1 at the positions of '\0', '\\', and '"'
+    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
 static inline const char *scan_string_noSIMD(const char *str, const char *end) {
-    for (; '"' != *str; str++) {
-        if (end <= str || '\0' == *str || '\\' == *str) {
+    for (; str < end; str++) {
+        if (end_of_scan_string[(unsigned char)*str]) {
             break;
         }
     }
@@ -195,14 +205,18 @@ static inline const char *scan_string_noSIMD(const char *str, const char *end) {
 #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);
+    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);
+        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);
+            str = (char *)(str + r);
             return str;
         }
     }
@@ -211,7 +225,7 @@ static inline const char *scan_string_SIMD(const char *str, const char *end) {
 }
 #endif
 
-static const char *(*scan_func) (const char *str, const char *end) = scan_string_noSIMD;
+static const char *(*scan_func)(const char *str, const char *end) = scan_string_noSIMD;
 
 void oj_scanner_init(void) {
 #ifdef OJ_USE_SSE4_2
@@ -232,16 +246,12 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
 
     for (s = pi->cur; '"' != *s;) {
         const char *scanned = scan_func(s, pi->end);
-        if (scanned >= pi->end) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "quoted string not terminated");
+        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;
         }
-
         buf_append_string(&buf, s, (size_t)(scanned - s));
         s = scanned;
 
@@ -275,11 +285,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;
                     }
@@ -306,11 +312,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;
             }
@@ -330,7 +332,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 {
@@ -342,9 +344,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;
@@ -373,11 +374,7 @@ static void read_str(ParseInfo pi) {
 
     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");
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
         return;
     }
     if (RB_UNLIKELY('\0' == *pi->cur)) {
@@ -412,9 +409,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;
@@ -440,6 +436,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;
@@ -456,7 +453,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;
     }
@@ -466,33 +463,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;
@@ -515,11 +500,7 @@ static void read_num(ParseInfo pi) {
             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");
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
             return;
         }
         if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
@@ -611,9 +592,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;
@@ -711,7 +691,7 @@ void oj_parse2(ParseInfo pi) {
     pi->cur = pi->json;
     err_init(&pi->err);
     while (1) {
-        if (0 < pi->max_depth && pi->max_depth <= pi->stack.tail - pi->stack.head - 1) {
+        if (RB_UNLIKELY(0 < pi->max_depth && pi->max_depth <= pi->stack.tail - pi->stack.head - 1)) {
             VALUE err_clas = oj_get_json_err_class("NestingError");
 
             oj_set_error_at(pi, err_clas, __FILE__, __LINE__, "Too deeply nested.");
@@ -719,18 +699,20 @@ void oj_parse2(ParseInfo pi) {
             return;
         }
         next_non_white(pi);
-        if (!first && '\0' != *pi->cur) {
-            oj_set_error_at(pi,
-                            oj_parse_error_class,
-                            __FILE__,
-                            __LINE__,
-                            "unexpected characters after the JSON document");
-        }
-
-        // If no tokens are consumed (i.e. empty string), throw a parse error
-        // this is the behavior of JSON.parse in both Ruby and JS.
-        if (No == pi->options.empty_string && 1 == first && '\0' == *pi->cur) {
-            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
+        if (first) {
+            // If no tokens are consumed (i.e. empty string), throw a parse error
+            // this is the behavior of JSON.parse in both Ruby and JS.
+            if (RB_UNLIKELY('\0' == *pi->cur && No == pi->options.empty_string)) {
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
+            }
+        } else {
+            if (RB_UNLIKELY('\0' != *pi->cur)) {
+                oj_set_error_at(pi,
+                                oj_parse_error_class,
+                                __FILE__,
+                                __LINE__,
+                                "unexpected characters after the JSON document");
+            }
         }
 
         switch (*pi->cur++) {
@@ -740,17 +722,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--;
@@ -776,11 +751,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;
@@ -800,11 +771,9 @@ 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)) {
+        if (RB_UNLIKELY(err_has(&pi->err))) {
             return;
         }
         if (stack_empty(&pi->stack)) {
@@ -839,11 +808,10 @@ 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
@@ -867,12 +835,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) {
@@ -915,11 +883,15 @@ oj_num_as_value(NumInfo ni) {
 
             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);
         }
@@ -927,28 +899,23 @@ 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;
+    int     mlen;
 
     va_start(ap, format);
     mlen = vsnprintf(msg, sizeof(msg) - 1, format, ap);
     if (0 < mlen) {
-	if (sizeof(msg) - 2 < (size_t)mlen) {
-	    p = end - 2;
-	} else {
-	    p += mlen;
-	}
+        if (sizeof(msg) - 2 < (size_t)mlen) {
+            p = end - 2;
+        } else {
+            p += mlen;
+        }
     }
     va_end(ap);
     pi->err.clas = err_clas;
@@ -985,14 +952,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);
     }
@@ -1011,7 +971,7 @@ static void oj_pi_set_input_str(ParseInfo pi, VALUE *inputp) {
 
     if (oj_utf8_encoding_index != idx) {
         rb_encoding *enc = rb_enc_from_index(idx);
-        *inputp = rb_str_conv_enc(*inputp, enc, oj_utf8_encoding);
+        *inputp          = rb_str_conv_enc(*inputp, enc, oj_utf8_encoding);
     }
     pi->json = RSTRING_PTR(*inputp);
     pi->end  = pi->json + RSTRING_LEN(*inputp);
@@ -1019,12 +979,12 @@ static void oj_pi_set_input_str(ParseInfo pi, VALUE *inputp) {
 
 VALUE
 oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk) {
-    char * buf = 0;
-    VALUE  input;
-    VALUE  wrapped_stack;
-    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.");
@@ -1073,19 +1033,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
@@ -1111,8 +1070,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");
         }
     }
@@ -1140,9 +1098,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:
@@ -1160,9 +1116,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) {
@@ -1177,12 +1133,12 @@ CLEANUP:
             // 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.
-            VALUE msg = oj_encode(rb_str_new2(pi->err.msg));
+            VALUE msg = rb_utf8_str_new_cstr(pi->err.msg);
             VALUE args[1];
 
             if (NULL != pi->json) {
-                msg = rb_str_append(msg, oj_encode(rb_str_new2(" in '")));
-                msg = rb_str_append(msg, oj_encode(rb_str_new2(pi->json)));
+                msg = rb_str_append(msg, rb_utf8_str_new_cstr(" in '"));
+                msg = rb_str_append(msg, rb_utf8_str_new_cstr(pi->json));
             }
             args[0] = msg;
             if (pi->err.clas == oj_parse_error_class) {

data/ext/oj/parse.h

@@ -16,23 +16,25 @@
 #include "val_stack.h"
 
 struct _rxClass;
+struct _parseInfo;
 
 typedef struct _numInfo {
-    int64_t     i;
-    int64_t     num;
-    int64_t     div;
-    int64_t     di;
-    const char *str;
-    size_t      len;
-    long        exp;
-    int         big;
-    int         infinity;
-    int         nan;
-    int         neg;
-    int         has_exp;
-    int         no_big;
-    int         bigdec_load;
-} * NumInfo;
+    int64_t            i;
+    int64_t            num;
+    int64_t            div;
+    int64_t            di;
+    const char        *str;
+    size_t             len;
+    long               exp;
+    struct _parseInfo *pi;
+    int                big;
+    int                infinity;
+    int                nan;
+    int                neg;
+    int                has_exp;
+    int                no_big;
+    int                bigdec_load;
+} *NumInfo;
 
 typedef struct _parseInfo {
     // used for the string parser
@@ -54,11 +56,7 @@ typedef struct _parseInfo {
     VALUE (*start_hash)(struct _parseInfo *pi);
     void (*end_hash)(struct _parseInfo *pi);
     VALUE (*hash_key)(struct _parseInfo *pi, const char *key, size_t klen);
-    void (*hash_set_cstr)(struct _parseInfo *pi,
-                          Val                kval,
-                          const char *       str,
-                          size_t             len,
-                          const char *       orig);
+    void (*hash_set_cstr)(struct _parseInfo *pi, Val kval, const char *str, size_t len, const char *orig);
     void (*hash_set_num)(struct _parseInfo *pi, Val kval, NumInfo ni);
     void (*hash_set_value)(struct _parseInfo *pi, Val kval, VALUE value);
 
@@ -73,11 +71,10 @@ typedef struct _parseInfo {
     void (*add_value)(struct _parseInfo *pi, VALUE val);
     VALUE err_class;
     bool  has_callbacks;
-} * ParseInfo;
+} *ParseInfo;
 
-extern void oj_parse2(ParseInfo pi);
-extern void
-             oj_set_error_at(ParseInfo pi, VALUE err_clas, const char *file, int line, const char *format, ...);
+extern void  oj_parse2(ParseInfo pi);
+extern void  oj_set_error_at(ParseInfo pi, VALUE err_clas, const char *file, int line, const char *format, ...);
 extern VALUE oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk);
 extern VALUE oj_num_as_value(NumInfo ni);