oj 3.16.0 → 3.17.3

data/ext/oj/oj.h

@@ -104,61 +104,64 @@ typedef enum {
 } StreamWriterType;
 
 typedef struct _dumpOpts {
-    bool    use;
-    char    indent_str[16];
-    char    before_sep[16];
-    char    after_sep[16];
-    char    hash_nl[16];
-    char    array_nl[16];
-    uint8_t indent_size;
-    uint8_t before_size;
-    uint8_t after_size;
-    uint8_t hash_size;
-    uint8_t array_size;
-    char    nan_dump;  // NanDump
-    bool    omit_nil;
-    bool    omit_null_byte;
-    int     max_depth;
+    bool        use;
+    char        indent_str[16];
+    char        before_sep[16];
+    char        after_sep[16];
+    char        hash_nl[16];
+    char        array_nl[16];
+    uint8_t     indent_size;
+    uint8_t     before_size;
+    uint8_t     after_size;
+    uint8_t     hash_size;
+    uint8_t     array_size;
+    char        nan_dump;  // NanDump
+    bool        omit_nil;
+    bool        omit_null_byte;
+    int         max_depth;
+    const char *only;
+    const char *except;
 } *DumpOpts;
 
 typedef struct _options {
-    int              indent;         // indention for dump, default 2
-    char             circular;       // YesNo
-    char             auto_define;    // YesNo
-    char             sym_key;        // YesNo
-    char             escape_mode;    // Escape_Mode
-    char             mode;           // Mode
-    char             class_cache;    // YesNo
-    char             time_format;    // TimeFormat
-    char             bigdec_as_num;  // YesNo
-    char             bigdec_load;    // BigLoad
-    char             compat_bigdec;  // boolean (0 or 1)
-    char             to_hash;        // YesNo
-    char             to_json;        // YesNo
-    char             as_json;        // YesNo
-    char             raw_json;       // YesNo
-    char             nilnil;         // YesNo
-    char             empty_string;   // YesNo
-    char             allow_gc;       // allow GC during parse
-    char             quirks_mode;    // allow single JSON values instead of documents
-    char             allow_invalid;  // YesNo - allow invalid unicode
-    char             create_ok;      // YesNo allow create_id
-    char             allow_nan;      // YEsyNo for parsing only
-    char             trace;          // YesNo
-    char             safe;           // YesNo
-    char             sec_prec_set;   // boolean (0 or 1)
-    char             ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
-    char             cache_keys;     // YesNo
-    char             cache_str;      // string short than or equal to this are cache
-    int64_t          int_range_min;  // dump numbers below as string
-    int64_t          int_range_max;  // dump numbers above as string
-    const char      *create_id;      // 0 or string
-    size_t           create_id_len;  // length of create_id
-    int              sec_prec;       // second precision when dumping time
-    char             float_prec;     // float precision, linked to float_fmt
-    char             float_fmt[7];   // float format for dumping, if empty use Ruby
-    VALUE            hash_class;     // class to use in place of Hash on load
-    VALUE            array_class;    // class to use in place of Array on load
+    int              indent;              // indention for dump, default 2
+    char             circular;            // YesNo
+    char             auto_define;         // YesNo
+    char             sym_key;             // YesNo
+    char             escape_mode;         // Escape_Mode
+    char             mode;                // Mode
+    char             class_cache;         // YesNo
+    char             time_format;         // TimeFormat
+    char             bigdec_as_num;       // YesNo
+    char             bigdec_load;         // BigLoad
+    char             compat_bigdec;       // boolean (0 or 1)
+    char             to_hash;             // YesNo
+    char             to_json;             // YesNo
+    char             as_json;             // YesNo
+    char             raw_json;            // YesNo
+    char             nilnil;              // YesNo
+    char             empty_string;        // YesNo
+    char             allow_gc;            // allow GC during parse
+    char             quirks_mode;         // allow single JSON values instead of documents
+    char             allow_invalid;       // YesNo - allow invalid unicode
+    char             create_ok;           // YesNo allow create_id
+    char             allow_nan;           // YesNo for parsing only
+    char             trace;               // YesNo
+    char             safe;                // YesNo
+    char             sec_prec_set;        // boolean (0 or 1)
+    char             ignore_under;        // YesNo - ignore attrs starting with _ if true in object and custom modes
+    char             cache_keys;          // YesNo
+    char             cache_str;           // string short than or equal to this are cache
+    int64_t          int_range_min;       // dump numbers below as string
+    int64_t          int_range_max;       // dump numbers above as string
+    size_t           max_integer_digits;  // 0 = unlimited; max decimal digits for parsed integers
+    const char      *create_id;           // 0 or string
+    size_t           create_id_len;       // length of create_id
+    int              sec_prec;            // second precision when dumping time
+    char             float_prec;          // float precision, linked to float_fmt
+    char             float_fmt[7];        // float format for dumping, if empty use Ruby
+    VALUE            hash_class;          // class to use in place of Hash on load
+    VALUE            array_class;         // class to use in place of Array on load
     struct _dumpOpts dump_opts;
     struct _rxClass  str_rx;
     VALUE           *ignore;  // Qnil terminated array of classes or NULL
@@ -262,6 +265,8 @@ extern void  oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
 extern void  oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
 extern char *oj_longlong_to_string(long long num, bool negative, char *buf);
 
+extern StrWriter oj_str_writer_unwrap(VALUE writer);
+
 extern void oj_str_writer_push_key(StrWriter sw, const char *key);
 extern void oj_str_writer_push_object(StrWriter sw, const char *key);
 extern void oj_str_writer_push_array(StrWriter sw, const char *key);
@@ -311,9 +316,7 @@ extern VALUE oj_ascii_only_sym;
 extern VALUE oj_create_additions_sym;
 extern VALUE oj_decimal_class_sym;
 extern VALUE oj_hash_class_sym;
-extern VALUE oj_in_sym;
 extern VALUE oj_indent_sym;
-extern VALUE oj_nanosecond_sym;
 extern VALUE oj_max_nesting_sym;
 extern VALUE oj_object_class_sym;
 extern VALUE oj_object_nl_sym;
@@ -331,10 +334,10 @@ extern ID oj_array_append_id;
 extern ID oj_array_end_id;
 extern ID oj_array_start_id;
 extern ID oj_as_json_id;
-extern ID oj_at_id;
 extern ID oj_begin_id;
 extern ID oj_bigdecimal_id;
 extern ID oj_end_id;
+extern ID oj_eofq_id;
 extern ID oj_error_id;
 extern ID oj_exclude_end_id;
 extern ID oj_file_id;
@@ -349,6 +352,7 @@ extern ID oj_json_create_id;
 extern ID oj_length_id;
 extern ID oj_new_id;
 extern ID oj_parse_id;
+extern ID oj_plus_id;
 extern ID oj_pos_id;
 extern ID oj_read_id;
 extern ID oj_readpartial_id;

data/ext/oj/parse.c

@@ -15,12 +15,9 @@
 #include "mem.h"
 #include "oj.h"
 #include "rxclass.h"
+#include "simd.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)
 
@@ -183,32 +180,189 @@ 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;
         }
     }
     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);
+#ifdef HAVE_SIMD_NEON
+
+static inline const char *string_scan_neon(const char *str, const char *end) {
+    const uint8x16_t null_char = vdupq_n_u8(0);
+    const uint8x16_t backslash = vdupq_n_u8('\\');
+    const uint8x16_t quote     = vdupq_n_u8('"');
+
+    while (str + sizeof(uint8x16_t) <= end) {
+        uint8x16_t      chunk = vld1q_u8((const uint8_t *)str);
+        uint8x16_t      tmp   = vorrq_u8(vorrq_u8(vceqq_u8(chunk, null_char), vceqq_u8(chunk, backslash)),
+                                         vceqq_u8(chunk, quote));
+        const uint8x8_t res   = vshrn_n_u16(vreinterpretq_u16_u8(tmp), 4);
+        uint64_t        mask  = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+        if (mask != 0) {
+            mask &= 0x8888888888888888ull;
+            return str + (OJ_CTZ64(mask) >> 2);
+        }
+        str += sizeof(uint8x16_t);
+    }
+
+    return scan_string_noSIMD(str, end);
+}
+
+#endif
+
+#ifdef HAVE_SIMD_SSE4_2
+// Optimized SIMD string scanner using SSE4.2 instructions
+// Uses prefetching and processes multiple chunks in parallel to reduce latency
+// Note: OJ_TARGET_SSE42 attribute allows this to compile even without global -msse4.2
+static OJ_TARGET_SSE42 const char *scan_string_SSE42(const char *str, const char *end) {
+    static const char chars[16]   = "\x00\\\"";
+    const __m128i     terminate   = _mm_loadu_si128((const __m128i *)&chars[0]);
+    const char       *safe_end_64 = end - 64;
+    const char       *safe_end_16 = end - 16;
+
+    // Process 64 bytes at a time with parallel SIMD operations
+    // This reduces pipeline stalls and improves instruction-level parallelism
+    while (str <= safe_end_64) {
+        // Prefetch next cache line for better memory throughput
+        OJ_PREFETCH(str + 64);
+
+        // Load and compare 4 chunks in parallel
+        const __m128i chunk0 = _mm_loadu_si128((const __m128i *)(str));
+        const __m128i chunk1 = _mm_loadu_si128((const __m128i *)(str + 16));
+        const __m128i chunk2 = _mm_loadu_si128((const __m128i *)(str + 32));
+        const __m128i chunk3 = _mm_loadu_si128((const __m128i *)(str + 48));
+
+        const int r0 = _mm_cmpestri(terminate,
+                                    3,
+                                    chunk0,
+                                    16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (OJ_UNLIKELY(r0 != 16))
+            return str + r0;
+
+        const int r1 = _mm_cmpestri(terminate,
+                                    3,
+                                    chunk1,
+                                    16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (OJ_UNLIKELY(r1 != 16))
+            return str + 16 + r1;
+
+        const int r2 = _mm_cmpestri(terminate,
+                                    3,
+                                    chunk2,
+                                    16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (OJ_UNLIKELY(r2 != 16))
+            return str + 32 + r2;
+
+        const int r3 = _mm_cmpestri(terminate,
+                                    3,
+                                    chunk3,
+                                    16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (OJ_UNLIKELY(r3 != 16))
+            return str + 48 + r3;
+
+        str += 64;
+    }
 
-    for (; str <= _end; str += 16) {
+    // Handle remaining 16-byte chunks
+    for (; str <= safe_end_16; 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;
-        }
+                                            3,
+                                            string,
+                                            16,
+                                            _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (r != 16)
+            return str + r;
+    }
+
+    return scan_string_noSIMD(str, end);
+}
+#endif
+
+#ifdef HAVE_SIMD_SSE2
+// Optimized SSE2 string scanner (fallback for older x86_64 CPUs)
+// Uses SSE2 instructions with prefetching and parallel processing
+// Note: OJ_TARGET_SSE2 attribute allows this to compile even without global -msse2
+static OJ_TARGET_SSE2 const char *scan_string_SSE2(const char *str, const char *end) {
+    const char *safe_end_64 = end - 64;
+    const char *safe_end_16 = end - 16;
+
+    // Create comparison vectors for our three special characters
+    const __m128i null_char = _mm_setzero_si128();
+    const __m128i backslash = _mm_set1_epi8('\\');
+    const __m128i quote     = _mm_set1_epi8('"');
+
+    // Process 64 bytes at a time for better throughput
+    while (str <= safe_end_64) {
+        OJ_PREFETCH(str + 64);
+
+        // Load 4 chunks
+        const __m128i chunk0 = _mm_loadu_si128((const __m128i *)(str));
+        const __m128i chunk1 = _mm_loadu_si128((const __m128i *)(str + 16));
+        const __m128i chunk2 = _mm_loadu_si128((const __m128i *)(str + 32));
+        const __m128i chunk3 = _mm_loadu_si128((const __m128i *)(str + 48));
+
+        // Compare all chunks (allows CPU to parallelize)
+        const __m128i cmp0 = _mm_or_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(chunk0, null_char), _mm_cmpeq_epi8(chunk0, backslash)),
+            _mm_cmpeq_epi8(chunk0, quote));
+        const __m128i cmp1 = _mm_or_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(chunk1, null_char), _mm_cmpeq_epi8(chunk1, backslash)),
+            _mm_cmpeq_epi8(chunk1, quote));
+        const __m128i cmp2 = _mm_or_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(chunk2, null_char), _mm_cmpeq_epi8(chunk2, backslash)),
+            _mm_cmpeq_epi8(chunk2, quote));
+        const __m128i cmp3 = _mm_or_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(chunk3, null_char), _mm_cmpeq_epi8(chunk3, backslash)),
+            _mm_cmpeq_epi8(chunk3, quote));
+
+        // Convert to masks
+        int mask0 = _mm_movemask_epi8(cmp0);
+        if (OJ_UNLIKELY(mask0 != 0))
+            return str + OJ_CTZ(mask0);
+
+        int mask1 = _mm_movemask_epi8(cmp1);
+        if (OJ_UNLIKELY(mask1 != 0))
+            return str + 16 + OJ_CTZ(mask1);
+
+        int mask2 = _mm_movemask_epi8(cmp2);
+        if (OJ_UNLIKELY(mask2 != 0))
+            return str + 32 + OJ_CTZ(mask2);
+
+        int mask3 = _mm_movemask_epi8(cmp3);
+        if (OJ_UNLIKELY(mask3 != 0))
+            return str + 48 + OJ_CTZ(mask3);
+
+        str += 64;
+    }
+
+    // Handle remaining 16-byte chunks
+    for (; str <= safe_end_16; str += 16) {
+        const __m128i chunk   = _mm_loadu_si128((const __m128i *)str);
+        const __m128i matches = _mm_or_si128(
+            _mm_or_si128(_mm_cmpeq_epi8(chunk, null_char), _mm_cmpeq_epi8(chunk, backslash)),
+            _mm_cmpeq_epi8(chunk, quote));
+        int mask = _mm_movemask_epi8(matches);
+        if (mask != 0)
+            return str + OJ_CTZ(mask);
     }
 
     return scan_string_noSIMD(str, end);
@@ -218,16 +372,29 @@ static inline const char *scan_string_SIMD(const char *str, const char *end) {
 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;
+    // Use runtime CPU detection to select the best SIMD implementation
+    // This ensures we don't crash on CPUs that don't support SSE4.2
+    SIMD_Implementation impl = oj_get_simd_implementation();
+
+    switch (impl) {
+#ifdef HAVE_SIMD_SSE4_2
+    case SIMD_SSE42: scan_func = scan_string_SSE42; break;
+#endif
+#ifdef HAVE_SIMD_SSE2
+    case SIMD_SSE2: scan_func = scan_string_SSE2; break;
+#endif
+#ifdef HAVE_SIMD_NEON
+    case SIMD_NEON: scan_func = string_scan_neon; break;
 #endif
+    default: scan_func = scan_string_noSIMD; break;
+    }
 }
 
 // entered at /
 static void read_escaped_str(ParseInfo pi, const char *start) {
     struct _buf buf;
     const char *s;
-    int         cnt = (int)(pi->cur - start);
+    size_t      cnt = pi->cur - start;
     uint32_t    code;
     Val         parent = stack_peek(&pi->stack);
 
@@ -444,7 +611,7 @@ static void read_num(ParseInfo pi) {
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
         ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
-                     RubyDec == pi->options.bigdec_load);
+                          RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
 
@@ -502,7 +669,7 @@ static void read_num(ParseInfo pi) {
             // A trailing . is not a valid decimal but if encountered allow it
             // 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);
+                size_t pos = pi->cur - ni.str;
 
                 if (1 == pos || (2 == pos && ni.neg)) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
@@ -681,7 +848,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.");
@@ -689,18 +856,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++) {
@@ -761,7 +930,7 @@ void oj_parse2(ParseInfo pi) {
         case '\0': pi->cur--; 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)) {
@@ -802,6 +971,20 @@ static long double exp_plus[] = {
     1.0e39, 1.0e40, 1.0e41, 1.0e42, 1.0e43, 1.0e44, 1.0e45, 1.0e46, 1.0e47, 1.0e48, 1.0e49,
 };
 
+static void validate_integer_size(size_t limit, NumInfo ni) {
+    size_t digit_count = ni->len - (ni->neg ? 1 : 0);
+
+    if (digit_count > limit) {
+        oj_set_error_at(ni->pi,
+                        (Qnil != ni->pi->err_class) ? ni->pi->err_class : oj_parse_error_class,
+                        __FILE__,
+                        __LINE__,
+                        "integer exceeds :max_integer_digits (%lu > %lu)",
+                        (unsigned long)digit_count,
+                        (unsigned long)limit);
+    }
+}
+
 VALUE
 oj_num_as_value(NumInfo ni) {
     VALUE rnum = Qnil;
@@ -815,6 +998,12 @@ oj_num_as_value(NumInfo ni) {
     } else if (ni->nan) {
         rnum = rb_float_new(0.0 / 0.0);
     } else if (1 == ni->div && 0 == ni->exp && !ni->has_exp) {  // fixnum
+        size_t limit = (NULL != ni->pi) ? ni->pi->options.max_integer_digits : 0;
+
+        if (0 < limit) {
+            validate_integer_size(limit, ni);
+        }
+
         if (ni->big) {
             if (256 > ni->len) {
                 char buf[256];
@@ -875,7 +1064,11 @@ oj_num_as_value(NumInfo ni) {
             double d = strtod(ni->str, &end);
 
             if ((long)ni->len != (long)(end - ni->str)) {
-                rb_raise(ni->pi->err_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);
         }
@@ -1020,11 +1213,19 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             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) {
-                    OJ_R_FREE(buf);
+            {
+                size_t total = 0;
+
+                while (total < len) {
+                    cnt = read(fd, (char *)pi->json + total, len - total);
+                    if (cnt <= 0) {
+                        if (0 != buf) {
+                            OJ_R_FREE(buf);
+                        }
+                        rb_raise(rb_eIOError, "failed to read from IO Object.");
+                    }
+                    total += cnt;
                 }
-                rb_raise(rb_eIOError, "failed to read from IO Object.");
             }
             ((char *)pi->json)[len] = '\0';
             /* skip UTF-8 BOM if present */
@@ -1117,12 +1318,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) {