oj 3.16.6 → 3.17.3

data/ext/oj/rxclass.h

@@ -19,7 +19,7 @@ typedef struct _rxClass {
 extern void  oj_rxclass_init(RxClass rc);
 extern void  oj_rxclass_cleanup(RxClass rc);
 extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
-extern VALUE oj_rxclass_match(RxClass rc, const char *str, int len);
+extern VALUE oj_rxclass_match(RxClass rc, const char *str, size_t len);
 extern void  oj_rxclass_copy(RxClass src, RxClass dest);
 extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
 

data/ext/oj/safe.c

@@ -0,0 +1,230 @@
+
+#include "safe.h"
+
+static VALUE max_hash_size_sym, max_array_size_sym, max_depth_sym, max_total_elements_sym, max_hash_size_error_class,
+    max_array_size_error_class, max_depth_error_class, max_total_elements_error_class;
+
+static void check_object_size(safe_T safe) {
+    if (NIL_P(safe->max_hash_size)) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_hash  = (number_of_items_in_stack - current_object_location->vi - 1) / 2;
+
+    if (safe->max_hash_size > number_of_items_in_hash) {
+        return;
+    }
+
+    rb_raise(max_hash_size_error_class, "Too many object items!");
+}
+
+static void check_array_size(safe_T safe) {
+    if (NIL_P(safe->max_array_size)) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_array = number_of_items_in_stack - current_object_location->vi - 1;
+
+    if (safe->max_array_size > number_of_items_in_array) {
+        return;
+    }
+
+    rb_raise(max_array_size_error_class, "Too many array items!");
+}
+
+static void check_max_depth(safe_T safe, ojParser p) {
+    if (NIL_P(safe->max_depth) || safe->max_depth >= (p->depth + 1)) {
+        return;
+    }
+
+    rb_raise(max_depth_error_class, "JSON is too deep!");
+}
+
+static void check_max_total_elements(safe_T safe) {
+    /*
+    * We check if `max_total_elements` is greater than `current_elements_count`
+    * (instead of greater than or equal) because top-level elements (e.g., [],
+    * null, true) are not counted. As a result, `current_elements_count`
+    * always holds one less than the actual total.
+    */
+    if (NIL_P(safe->max_total_elements) || safe->max_total_elements > safe->current_elements_count) {
+        return;
+    }
+
+    rb_raise(max_total_elements_error_class, "Too many elements!");
+}
+
+static void safe_start(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size      = 0;
+    safe->current_array_size     = 0;
+    safe->current_elements_count = 0;
+
+    safe->delegated_start_func(p);
+}
+
+static void safe_open_object(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_func(p);
+}
+
+static void safe_open_array(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_func(p);
+}
+
+DEFINE_DELEGATED_FUNCTION(add_null);
+DEFINE_DELEGATED_FUNCTION(add_true);
+DEFINE_DELEGATED_FUNCTION(add_false);
+DEFINE_DELEGATED_FUNCTION(add_int);
+DEFINE_DELEGATED_FUNCTION(add_float);
+DEFINE_DELEGATED_FUNCTION(add_big);
+DEFINE_DELEGATED_FUNCTION(add_str);
+
+static void safe_open_object_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_key_func(p);
+}
+
+static void safe_open_array_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_key_func(p);
+}
+
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_null);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_true);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_false);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_int);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_float);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_big);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_str);
+
+void oj_init_safe_parser(ojParser p, safe_T safe, VALUE options) {
+    // Safe parser inherits all members of usual parser
+    oj_init_usual(p, &safe->usual);
+
+    safe->delegated_start_func = p->start;
+    p->start                   = safe_start;
+
+    Funcs f;
+
+    // Array parser functions
+    f                                = &p->funcs[ARRAY_FUN];
+    safe->delegated_open_object_func = f->open_object;
+    f->open_object                   = safe_open_object;
+    safe->delegated_open_array_func  = f->open_array;
+    f->open_array                    = safe_open_array;
+    // The following overrides are done for counting objects
+    safe->delegated_add_null_func  = f->add_null;
+    f->add_null                    = safe_add_null;
+    safe->delegated_add_true_func  = f->add_true;
+    f->add_true                    = safe_add_true;
+    safe->delegated_add_false_func = f->add_false;
+    f->add_false                   = safe_add_false;
+    safe->delegated_add_int_func   = f->add_int;
+    f->add_int                     = safe_add_int;
+    safe->delegated_add_float_func = f->add_float;
+    f->add_float                   = safe_add_float;
+    safe->delegated_add_big_func   = f->add_big;
+    f->add_big                     = safe_add_big;
+    safe->delegated_add_str_func   = f->add_str;
+    f->add_str                     = safe_add_str;
+
+    // Object parser functions
+    f                                    = &p->funcs[OBJECT_FUN];
+    safe->delegated_open_object_key_func = f->open_object;
+    f->open_object                       = safe_open_object_key;
+    safe->delegated_open_array_key_func  = f->open_array;
+    f->open_array                        = safe_open_array_key;
+    // The following overrides are done for counting objects
+    safe->delegated_add_null_key_func  = f->add_null;
+    f->add_null                        = safe_add_null_key;
+    safe->delegated_add_true_key_func  = f->add_true;
+    f->add_true                        = safe_add_true_key;
+    safe->delegated_add_false_key_func = f->add_false;
+    f->add_false                       = safe_add_false_key;
+    safe->delegated_add_int_key_func   = f->add_int;
+    f->add_int                         = safe_add_int_key;
+    safe->delegated_add_float_key_func = f->add_float;
+    f->add_float                       = safe_add_float_key;
+    safe->delegated_add_big_key_func   = f->add_big;
+    f->add_big                         = safe_add_big_key;
+    safe->delegated_add_str_key_func   = f->add_str;
+    f->add_str                         = safe_add_str_key;
+
+    SET_CONFIG(max_hash_size);
+    SET_CONFIG(max_array_size);
+    SET_CONFIG(max_depth);
+    SET_CONFIG(max_total_elements);
+}
+
+void oj_set_parser_safe(ojParser p, VALUE options) {
+    safe_T s = OJ_R_ALLOC(struct _safe_S);
+
+    oj_init_safe_parser(p, s, options);
+}
+
+void oj_safe_init(VALUE parser_class) {
+    VALUE validation_error_class = rb_define_class_under(parser_class, "ValidationError", rb_eRuntimeError);
+
+    max_hash_size_error_class      = rb_define_class_under(parser_class, "HashSizeError", validation_error_class);
+    max_array_size_error_class     = rb_define_class_under(parser_class, "ArraySizeError", validation_error_class);
+    max_depth_error_class          = rb_define_class_under(parser_class, "DepthError", validation_error_class);
+    max_total_elements_error_class = rb_define_class_under(parser_class, "TotalElementsError", validation_error_class);
+
+    rb_gc_register_address(&max_hash_size_error_class);
+    rb_gc_register_address(&max_array_size_error_class);
+    rb_gc_register_address(&max_depth_error_class);
+    rb_gc_register_address(&max_total_elements_error_class);
+
+    max_hash_size_sym      = ID2SYM(rb_intern("max_hash_size"));
+    max_array_size_sym     = ID2SYM(rb_intern("max_array_size"));
+    max_depth_sym          = ID2SYM(rb_intern("max_depth"));
+    max_total_elements_sym = ID2SYM(rb_intern("max_total_elements"));
+
+    rb_gc_register_address(&max_hash_size_sym);
+    rb_gc_register_address(&max_array_size_sym);
+    rb_gc_register_address(&max_depth_sym);
+    rb_gc_register_address(&max_total_elements_sym);
+}

data/ext/oj/safe.h

@@ -0,0 +1,79 @@
+#include <ruby.h>
+
+#include "parser.h"
+#include "usual.h"
+
+#define SET_CONFIG(config_name)                                                        \
+    do {                                                                               \
+        VALUE rb_##config_name = rb_hash_aref(options, config_name##_sym);             \
+                                                                                       \
+        if (RB_INTEGER_TYPE_P(rb_##config_name)) {                                     \
+            safe->config_name = NUM2LONG(rb_##config_name);                            \
+        } else if (!NIL_P(rb_##config_name)) {                                         \
+            rb_raise(rb_eArgError, "Incorrect value provided for `" #config_name "`"); \
+        } else {                                                                       \
+            safe->config_name = Qnil;                                                  \
+        }                                                                              \
+    } while (0);
+
+#define DEFINE_DELEGATED_FUNCTION(function_name)   \
+    static void safe_##function_name(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;              \
+                                                   \
+        safe->current_elements_count++;            \
+                                                   \
+        check_array_size(safe);                    \
+        check_max_total_elements(safe);            \
+                                                   \
+        safe->delegated_##function_name##_func(p); \
+    }
+
+#define DEFINE_DELEGATED_OBJECT_FUNCTION(function_name)  \
+    static void safe_##function_name##_key(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;                    \
+                                                         \
+        safe->current_elements_count += 2;               \
+                                                         \
+        check_object_size(safe);                         \
+        check_max_total_elements(safe);                  \
+                                                         \
+        safe->delegated_##function_name##_key_func(p);   \
+    }
+
+typedef struct _safe_S {
+    struct _usual usual;
+
+    long int max_hash_size;
+    long int max_array_size;
+    long int max_depth;
+    long int max_total_elements;
+    long int max_json_size_bytes;
+
+    long int current_hash_size;
+    long int current_array_size;
+    long int current_elements_count;
+
+    void (*delegated_start_func)(struct _ojParser *p);
+
+    // Array functions
+    void (*delegated_open_object_func)(struct _ojParser *p);
+    void (*delegated_open_array_func)(struct _ojParser *p);
+    void (*delegated_add_null_func)(struct _ojParser *p);
+    void (*delegated_add_true_func)(struct _ojParser *p);
+    void (*delegated_add_false_func)(struct _ojParser *p);
+    void (*delegated_add_int_func)(struct _ojParser *p);
+    void (*delegated_add_float_func)(struct _ojParser *p);
+    void (*delegated_add_big_func)(struct _ojParser *p);
+    void (*delegated_add_str_func)(struct _ojParser *p);
+
+    // Object functions
+    void (*delegated_open_object_key_func)(struct _ojParser *p);
+    void (*delegated_open_array_key_func)(struct _ojParser *p);
+    void (*delegated_add_null_key_func)(struct _ojParser *p);
+    void (*delegated_add_true_key_func)(struct _ojParser *p);
+    void (*delegated_add_false_key_func)(struct _ojParser *p);
+    void (*delegated_add_int_key_func)(struct _ojParser *p);
+    void (*delegated_add_float_key_func)(struct _ojParser *p);
+    void (*delegated_add_big_key_func)(struct _ojParser *p);
+    void (*delegated_add_str_key_func)(struct _ojParser *p);
+} *safe_T;

data/ext/oj/saj.c

@@ -94,8 +94,7 @@ inline static void call_add_value(VALUE handler, VALUE value, const char *key) {
     if (0 == key) {
         k = Qnil;
     } else {
-        k = rb_str_new2(key);
-        k = oj_encode(k);
+        k = rb_utf8_str_new_cstr(key);
     }
     rb_funcall(handler, oj_add_value_id, 2, value, k);
 }
@@ -106,8 +105,7 @@ inline static void call_no_value(VALUE handler, ID method, const char *key) {
     if (0 == key) {
         k = Qnil;
     } else {
-        k = rb_str_new2(key);
-        k = oj_encode(k);
+        k = rb_utf8_str_new_cstr(key);
     }
     rb_funcall(handler, method, 1, k);
 }
@@ -257,9 +255,8 @@ static void read_str(ParseInfo pi, const char *key) {
 
     text = read_quoted_value(pi);
     if (pi->has_add_value) {
-        VALUE s = rb_str_new2(text);
+        VALUE s = rb_utf8_str_new_cstr(text);
 
-        s = oj_encode(s);
         call_add_value(pi->handler, s, key);
     }
 }
@@ -651,8 +648,16 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             len = lseek(fd, 0, SEEK_END);
             lseek(fd, 0, SEEK_SET);
             json = OJ_R_ALLOC_N(char, len + 1);
-            if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
-                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            {
+                size_t total = 0;
+
+                while (total < len) {
+                    cnt = read(fd, json + total, len - total);
+                    if (cnt <= 0) {
+                        rb_raise(rb_eIOError, "failed to read from IO Object.");
+                    }
+                    total += cnt;
+                }
             }
             json[len] = '\0';
 #endif

data/ext/oj/scp.c

@@ -56,9 +56,8 @@ static void add_value(ParseInfo pi, VALUE val) {
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = rb_utf8_str_new(str, len);
 
-    rstr = oj_encode(rstr);
     rb_funcall(pi->handler, oj_add_value_id, 1, rstr);
 }
 
@@ -87,9 +86,8 @@ static VALUE hash_key(ParseInfo pi, const char *key, size_t klen) {
 }
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = rb_utf8_str_new(str, len);
 
-    rstr = oj_encode(rstr);
     rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, kval), rstr);
 }
 
@@ -107,9 +105,8 @@ static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = rb_utf8_str_new(str, len);
 
-    rstr = oj_encode(rstr);
     rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, rstr);
 }
 

data/ext/oj/simd.h

@@ -0,0 +1,219 @@
+#ifndef OJ_SIMD_H
+#define OJ_SIMD_H
+
+// SIMD architecture detection and configuration
+// This header provides unified SIMD support across different CPU architectures
+// with cross-platform runtime detection (Windows/Linux/Mac)
+
+// SIMD implementation enum - used for runtime selection
+typedef enum _simd_implementation { SIMD_NONE, SIMD_NEON, SIMD_SSE2, SIMD_SSE42 } SIMD_Implementation;
+
+// Define in oj.c.
+extern SIMD_Implementation SIMD_Impl;
+
+// Runtime CPU detection function (implemented in oj.c)
+SIMD_Implementation oj_get_simd_implementation(void);
+
+// =============================================================================
+// Compiler compatibility macros
+// =============================================================================
+
+// Branch prediction hints
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_LIKELY(x) __builtin_expect(!!(x), 1)
+#define OJ_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define OJ_LIKELY(x) (x)
+#define OJ_UNLIKELY(x) (x)
+#endif
+
+// Prefetch hints
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_PREFETCH(addr) __builtin_prefetch(addr, 0, 0)
+#elif defined(_MSC_VER)
+#include <intrin.h>
+#define OJ_PREFETCH(addr) _mm_prefetch((const char *)(addr), _MM_HINT_T0)
+#else
+#define OJ_PREFETCH(addr) ((void)0)
+#endif
+
+// Count trailing zeros (for SSE2 mask scanning)
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_CTZ(x) __builtin_ctz(x)
+#define OJ_CTZ64(x) __builtin_ctzll(x)
+#elif defined(_MSC_VER)
+#include <intrin.h>
+static __inline int oj_ctz_msvc(unsigned int x) {
+    unsigned long index;
+    if (0 == x) {
+        return 32;
+    }
+    _BitScanForward(&index, x);
+    return (int)index;
+}
+static __inline int oj_ctz64_msvc(uint64_t x) {
+    unsigned long index;
+    if (_BitScanForward64(&index, x)) {
+        return (int)index;
+    }
+    return 64;
+}
+#define OJ_CTZ(x) oj_ctz_msvc(x)
+#define OJ_CTZ64(x) oj_ctz64_msvc(x)
+#else
+// Fallback: naive implementation
+static inline int oj_ctz_fallback(unsigned int x) {
+    int count = 0;
+    while ((x & 1) == 0 && count < 32) {
+        x >>= 1;
+        count++;
+    }
+    return count;
+}
+
+static inline int oj_ctz64_fallback(uint64_t x) {
+    int count = 0;
+    while ((x & 1) == 0 && count < 64) {
+        x >>= 1;
+        count++;
+    }
+    return count;
+}
+#define OJ_CTZ(x) oj_ctz_fallback(x)
+#define OJ_CTZ64(x) oj_ctz64_fallback(x)
+#endif
+
+// =============================================================================
+// x86/x86_64 SIMD detection
+// =============================================================================
+#if defined(__x86_64__) || defined(__i386__) || defined(_M_IX86) || defined(_M_X64)
+#define HAVE_SIMD_X86 1
+
+// Include appropriate SIMD headers
+#if defined(_MSC_VER)
+// MSVC: use intrin.h for all intrinsics
+#include <intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif defined(__GNUC__) || defined(__clang__)
+// GCC/Clang: check for header availability and include them
+// We include headers but use target attributes to enable instructions per-function
+// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable
+#if __has_include(<cpuid.h>)
+#include <cpuid.h>
+#endif
+#if defined(__SSE4_2__) || defined(__SSE2__)
+// If any SSE is enabled globally, x86intrin.h should be available
+#include <x86intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#else
+// Try to include headers anyway for target attribute functions
+#if __has_include(<x86intrin.h>)
+#include <x86intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif __has_include(<nmmintrin.h>)
+#include <nmmintrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif __has_include(<emmintrin.h>)
+#include <emmintrin.h>
+#define HAVE_SIMD_SSE2 1
+#endif
+#endif
+#endif
+
+// Target attribute macros for function-level SIMD enabling
+#if defined(__clang__) || defined(__GNUC__)
+#define OJ_TARGET_SSE42 __attribute__((target("sse4.2")))
+#define OJ_TARGET_SSE2 __attribute__((target("sse2")))
+#else
+// MSVC doesn't need target attributes - intrinsics are always available
+#define OJ_TARGET_SSE42
+#define OJ_TARGET_SSE2
+#endif
+
+#endif  // x86/x86_64
+
+// =============================================================================
+// ARM NEON detection
+// =============================================================================
+#if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM64)
+#define HAVE_SIMD_NEON 1
+#define SIMD_MINIMUM_THRESHOLD 6
+#include <arm_neon.h>
+#endif
+
+// =============================================================================
+// SIMD type string for debugging/logging
+// =============================================================================
+#if defined(HAVE_SIMD_SSE4_2) || defined(HAVE_SIMD_SSE2)
+#define HAVE_SIMD_STRING_SCAN 1
+#define SIMD_TYPE "x86 (runtime detected)"
+#elif defined(HAVE_SIMD_NEON)
+#define HAVE_SIMD_STRING_SCAN 1
+#define SIMD_TYPE "NEON"
+#else
+#define SIMD_TYPE "none"
+#endif
+
+#if defined(HAVE_SIMD_SSE4_2)
+
+#define SIMD_MINIMUM_THRESHOLD 6
+
+extern void initialize_sse42(void);
+
+static inline OJ_TARGET_SSE42 __m128i vector_lookup_sse42(__m128i input, __m128i *lookup_table, int tab_size) {
+    // Extract high 4 bits to determine which 16-byte chunk (0-15)
+    __m128i hi_index = _mm_and_si128(_mm_srli_epi32(input, 4), _mm_set1_epi8(0x0F));
+
+    // Extract low 4 bits for index within the chunk (0-15)
+    __m128i low_index = _mm_and_si128(input, _mm_set1_epi8(0x0F));
+
+    // Perform lookups in all 16 tables
+    __m128i results[16];
+    for (int i = 0; i < tab_size; i++) {
+        results[i] = _mm_shuffle_epi8(lookup_table[i], low_index);
+    }
+
+    // Create masks for each chunk and blend results
+    __m128i final_result = _mm_setzero_si128();
+
+    for (int i = 0; i < tab_size; i++) {
+        __m128i mask          = _mm_cmpeq_epi8(hi_index, _mm_set1_epi8(i));
+        __m128i masked_result = _mm_and_si128(mask, results[i]);
+        final_result          = _mm_or_si128(final_result, masked_result);
+    }
+
+    return final_result;
+}
+
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#if __has_builtin(__builtin_memcpy)
+#define HAVE_FAST_MEMCPY 1
+
+inline static void fast_memcpy16(void *dest, const void *src, size_t n) {
+    char *d = (char *)dest;
+    char *s = (char *)src;
+    if (n >= 8) {
+        __builtin_memcpy(d, s, 8);
+        __builtin_memcpy(d + n - 8, s + n - 8, 8);
+    } else if (n >= 4) {
+        __builtin_memcpy(d, s, 4);
+        __builtin_memcpy(d + n - 4, s + n - 4, 4);
+    } else if (n >= 2) {
+        __builtin_memcpy(d, s, 2);
+        __builtin_memcpy(d + n - 2, s + n - 2, 2);
+    } else if (n >= 1) {
+        *d = *s;
+    }
+}
+#endif
+
+#endif /* OJ_SIMD_H */

data/ext/oj/sparse.c

@@ -399,6 +399,7 @@ static void read_num(ParseInfo pi) {
     char            c;
 
     reader_protect(&pi->rd);
+    ni.pi       = pi;
     ni.i        = 0;
     ni.num      = 0;
     ni.div      = 1;
@@ -415,7 +416,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;
     }
 
@@ -549,6 +550,7 @@ static void read_nan(ParseInfo pi) {
     struct _numInfo ni;
     char            c;
 
+    ni.pi       = pi;
     ni.str      = pi->rd.str;
     ni.i        = 0;
     ni.num      = 0;
@@ -565,7 +567,7 @@ static void read_nan(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;
     }
 
@@ -745,6 +747,7 @@ void oj_sparse2(ParseInfo pi) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected NaN");
                     return;
                 }
+                ni.pi       = pi;
                 ni.str      = pi->rd.str;
                 ni.i        = 0;
                 ni.num      = 0;
@@ -761,7 +764,7 @@ void oj_sparse2(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;
                 }
                 add_num_value(pi, &ni);

data/ext/oj/stream_writer.c

@@ -42,22 +42,12 @@ static void stream_writer_write(StreamWriter sw) {
 
     switch (sw->type) {
     case STRING_IO:
-    case STREAM_IO: {
-        volatile VALUE rs = rb_str_new(sw->sw.out.buf, size);
-
-        // Oddly enough, when pushing ASCII characters with UTF-8 encoding or
-        // even ASCII-8BIT does not change the output encoding. Pushing any
-        // non-ASCII no matter what the encoding changes the output encoding
-        // to ASCII-8BIT if it the string is not forced to UTF-8 here.
-        rs = oj_encode(rs);
+    case STREAM_IO:
+    case FILE_IO: {
+        volatile VALUE rs = rb_utf8_str_new(sw->sw.out.buf, size);
         rb_funcall(sw->stream, oj_write_id, 1, rs);
         break;
     }
-    case FILE_IO:
-        if (size != write(sw->fd, sw->sw.out.buf, size)) {
-            rb_raise(rb_eIOError, "Write failed. [_%d_:%s]\n", errno, strerror(errno));
-        }
-        break;
     default: rb_raise(rb_eArgError, "expected an IO Object.");
     }
     stream_writer_reset_buf(sw);