oj 3.16.10 → 3.16.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1095d7a176bd19396bd99cf23df33564dbdf983b36a74254085700a12ce4293
-  data.tar.gz: ef1b5958d6edf181843066dc4b60a93e861779cfa387b88d0f866d642c3e9a6c
+  metadata.gz: 30aea721380a4e3edc306dd19906d8777f230a639ba3427e9394dd543a3a7e3b
+  data.tar.gz: b024a9d4513c16c1bfe4fc3c4adeacb1afd9a0e670987476d32cfa2fa74e9b1e
 SHA512:
-  metadata.gz: c396a33f0a2e64282f13a1b834c8804429f97de515dffcf1e8cba852fbe645301c9f6b0e7d64552a795c70e0262e8828f650a1ac9243391af8c07a2ecd621f35
-  data.tar.gz: 43ddbc0d8f2d5bea7580b0f88fa2c4981a661098f3e041aac6f8185029e2018f99ef33478ebbf62b35c31357f1d48adb25f6889b6049054add214a834e8e696a
+  metadata.gz: 527ea1162cb135bbe16eefc10a7cb05444182767aca6fa0b6986622e52d7082bcec020c43e663251406c81602018f7d0842c2c5cee37aeca0269560e502d99dd
+  data.tar.gz: e49e9f63e373cb0ec21f604f97899f87815b86ef5a5eafad30e7bddbd11e71156f92beaa1259c83609c2d45d2a8aac87c8b27e3e266fcc2bd99a1908327c796d

data/CHANGELOG.md

@@ -1,9 +1,15 @@
 # CHANGELOG
 
+## 3.16.11 - 2025-05-29
+
+- Fixed range encoding with the :circular option
+
 ## 3.16.10 - 2025-02-24
 
 - Changed oj_parser_type to be non-static.
 
+- Changed ARM versions to used Neon instructions thanks to @samyron.
+
 ## 3.16.9 - 2024-12-28
 
 - Fixed `Oj::Parser` create_id size issue #931.

data/ext/oj/custom.c

@@ -40,7 +40,7 @@ static void dump_obj_as_str(VALUE obj, int depth, Out out) {
 static void bigdecimal_dump(VALUE obj, int depth, Out out) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
     const char    *str  = RSTRING_PTR(rstr);
-    int            len  = (int)RSTRING_LEN(rstr);
+    size_t         len  = RSTRING_LEN(rstr);
 
     if (0 == strcasecmp("Infinity", str)) {
         str = oj_nan_str(obj, out->opts->dump_opts.nan_dump, out->opts->mode, true, &len);
@@ -123,7 +123,7 @@ static void date_dump(VALUE obj, int depth, Out out) {
         case RubyTime:
         case XmlTime:
             v = rb_funcall(obj, rb_intern("iso8601"), 0);
-            oj_dump_cstr(RSTRING_PTR(v), (int)RSTRING_LEN(v), 0, 0, out);
+            oj_dump_cstr(RSTRING_PTR(v), RSTRING_LEN(v), 0, 0, out);
             break;
         case UnixZTime:
             v = rb_funcall(obj, rb_intern("to_time"), 0);
@@ -405,7 +405,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.\n");
         } else {
             const char *s    = RSTRING_PTR(v);
-            int         len  = (int)RSTRING_LEN(v);
+            size_t      len  = RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
 
@@ -478,7 +478,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
     } else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
         volatile VALUE rs;
         const char    *s;
-        int            len;
+        size_t         len;
 
         TRACE(out->opts->trace, "to_json", obj, depth + 1, TraceRubyIn);
         if (0 == rb_obj_method_arity(obj, oj_to_json_id)) {
@@ -488,7 +488,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         }
         TRACE(out->opts->trace, "to_json", obj, depth + 1, TraceRubyOut);
         s   = RSTRING_PTR(rs);
-        len = (int)RSTRING_LEN(rs);
+        len = RSTRING_LEN(rs);
 
         assure_size(out, len + 1);
         APPEND_CHARS(out->cur, s, len);
@@ -509,7 +509,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         if (aj == obj) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
-            oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), false, false, out);
+            oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), false, false, out);
         } else {
             oj_dump_custom_val(aj, depth, out, true);
         }
@@ -676,7 +676,8 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
     long   id = oj_check_circular(a, out);
 
@@ -684,7 +685,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         oj_dump_nil(Qnil, depth, out, false);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     assure_size(out, 2);
     if (0 == cnt) {
@@ -795,7 +796,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
                 volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
                 name = RSTRING_PTR(s);
-                len  = (int)RSTRING_LEN(s);
+                len  = RSTRING_LEN(s);
             } else {
                 len  = snprintf(num_id, sizeof(num_id), "%d", i);
                 name = num_id;

data/ext/oj/dump.c

@@ -152,8 +152,77 @@ inline static size_t newline_friendly_size(const uint8_t *str, size_t len) {
     return calculate_string_size(str, len, newline_friendly_chars);
 }
 
+#ifdef HAVE_SIMD_NEON
+inline static uint8x16x4_t load_uint8x16_4(const unsigned char *table) {
+    uint8x16x4_t tab;
+    tab.val[0] = vld1q_u8(table);
+    tab.val[1] = vld1q_u8(table + 16);
+    tab.val[2] = vld1q_u8(table + 32);
+    tab.val[3] = vld1q_u8(table + 48);
+    return tab;
+}
+
+static uint8x16x4_t hibit_friendly_chars_neon[2];
+static uint8x16x4_t rails_friendly_chars_neon[2];
+static uint8x16x4_t rails_xss_friendly_chars_neon[4];
+
+void initialize_neon(void) {
+    // We only need the first 128 bytes of the hibit friendly chars table. Everything above 127 is
+    // set to 1. If that ever changes, the code will need to be updated.
+    hibit_friendly_chars_neon[0] = load_uint8x16_4((const unsigned char *)hibit_friendly_chars);
+    hibit_friendly_chars_neon[1] = load_uint8x16_4((const unsigned char *)hibit_friendly_chars + 64);
+
+    // rails_friendly_chars is the same as hibit_friendly_chars. Only the first 128 bytes have values
+    // that are not '1'. If that ever changes, the code will need to be updated.
+    rails_friendly_chars_neon[0] = load_uint8x16_4((const unsigned char *)rails_friendly_chars);
+    rails_friendly_chars_neon[1] = load_uint8x16_4((const unsigned char *)rails_friendly_chars + 64);
+
+    rails_xss_friendly_chars_neon[0] = load_uint8x16_4((const unsigned char *)rails_xss_friendly_chars);
+    rails_xss_friendly_chars_neon[1] = load_uint8x16_4((const unsigned char *)rails_xss_friendly_chars + 64);
+    rails_xss_friendly_chars_neon[2] = load_uint8x16_4((const unsigned char *)rails_xss_friendly_chars + 128);
+    rails_xss_friendly_chars_neon[3] = load_uint8x16_4((const unsigned char *)rails_xss_friendly_chars + 192);
+
+    // All bytes should be 0 except for those that need more than 1 byte of output. This will allow the
+    // code to limit the lookups to the first 128 bytes (values 0 - 127). Bytes above 127 will result
+    // in 0 with the vqtbl4q_u8 instruction.
+    uint8x16_t one = vdupq_n_u8('1');
+    for (int i = 0; i < 2; i++) {
+        for (int j = 0; j < 4; j++) {
+            hibit_friendly_chars_neon[i].val[j] = vsubq_u8(hibit_friendly_chars_neon[i].val[j], one);
+            rails_friendly_chars_neon[i].val[j] = vsubq_u8(rails_friendly_chars_neon[i].val[j], one);
+        }
+    }
+
+    for (int i = 0; i < 4; i++) {
+        for (int j = 0; j < 4; j++) {
+            rails_xss_friendly_chars_neon[i].val[j] = vsubq_u8(rails_xss_friendly_chars_neon[i].val[j], one);
+        }
+    }
+}
+#endif
+
 inline static size_t hibit_friendly_size(const uint8_t *str, size_t len) {
+#ifdef HAVE_SIMD_NEON
+    size_t size = 0;
+    size_t i    = 0;
+
+    for (; i + sizeof(uint8x16_t) <= len; i += sizeof(uint8x16_t), str += sizeof(uint8x16_t)) {
+        size += sizeof(uint8x16_t);
+
+        // See https://lemire.me/blog/2019/07/23/arbitrary-byte-to-byte-maps-using-arm-neon/
+        uint8x16_t chunk  = vld1q_u8(str);
+        uint8x16_t tmp1   = vqtbl4q_u8(hibit_friendly_chars_neon[0], chunk);
+        uint8x16_t tmp2   = vqtbl4q_u8(hibit_friendly_chars_neon[1], veorq_u8(chunk, vdupq_n_u8(0x40)));
+        uint8x16_t result = vorrq_u8(tmp1, tmp2);
+        uint8_t    tmp    = vaddvq_u8(result);
+        size += tmp;
+    }
+
+    size_t total = size + calculate_string_size(str, len - i, hibit_friendly_chars);
+    return total;
+#else
     return calculate_string_size(str, len, hibit_friendly_chars);
+#endif
 }
 
 inline static size_t slash_friendly_size(const uint8_t *str, size_t len) {
@@ -184,9 +253,43 @@ inline static size_t hixss_friendly_size(const uint8_t *str, size_t len) {
 
 inline static long rails_xss_friendly_size(const uint8_t *str, size_t len) {
     long    size = 0;
-    size_t  i    = len;
     uint8_t hi   = 0;
 
+#ifdef HAVE_SIMD_NEON
+    size_t i = 0;
+
+    uint8x16_t has_some_hibit = vdupq_n_u8(0);
+    uint8x16_t hibit          = vdupq_n_u8(0x80);
+    for (; i + sizeof(uint8x16_t) <= len; i += sizeof(uint8x16_t), str += sizeof(uint8x16_t)) {
+        size += sizeof(uint8x16_t);
+
+        uint8x16_t chunk = vld1q_u8(str);
+
+        // Check to see if any of these bytes have the high bit set.
+        has_some_hibit = vorrq_u8(has_some_hibit, vandq_u8(chunk, hibit));
+
+        uint8x16_t tmp1   = vqtbl4q_u8(rails_xss_friendly_chars_neon[0], chunk);
+        uint8x16_t tmp2   = vqtbl4q_u8(rails_xss_friendly_chars_neon[1], veorq_u8(chunk, vdupq_n_u8(0x40)));
+        uint8x16_t tmp3   = vqtbl4q_u8(rails_xss_friendly_chars_neon[2], veorq_u8(chunk, vdupq_n_u8(0x80)));
+        uint8x16_t tmp4   = vqtbl4q_u8(rails_xss_friendly_chars_neon[3], veorq_u8(chunk, vdupq_n_u8(0xc0)));
+        uint8x16_t result = vorrq_u8(tmp4, vorrq_u8(tmp3, vorrq_u8(tmp1, tmp2)));
+        uint8_t    tmp    = vaddvq_u8(result);
+        size += tmp;
+    }
+
+    // 'hi' should be set if any of the bytes we processed have the high bit set. It doesn't matter which ones.
+    hi = vmaxvq_u8(has_some_hibit) != 0;
+
+    for (; i < len; str++, i++) {
+        size += rails_xss_friendly_chars[*str] - '0';
+        hi |= *str & 0x80;
+    }
+    if (0 == hi) {
+        return size;
+    }
+    return -(size);
+#else
+    size_t i = len;
     for (; 0 < i; str++, i--) {
         size += rails_xss_friendly_chars[*str];
         hi |= *str & 0x80;
@@ -195,13 +298,47 @@ inline static long rails_xss_friendly_size(const uint8_t *str, size_t len) {
         return size - len * (size_t)'0';
     }
     return -(size - len * (size_t)'0');
+#endif /* HAVE_SIMD_NEON */
 }
 
 inline static size_t rails_friendly_size(const uint8_t *str, size_t len) {
     long    size = 0;
-    size_t  i    = len;
     uint8_t hi   = 0;
+#ifdef HAVE_SIMD_NEON
+    size_t i = 0;
+
+    uint8x16_t has_some_hibit = vdupq_n_u8(0);
+    uint8x16_t hibit          = vdupq_n_u8(0x80);
+
+    for (; i + sizeof(uint8x16_t) <= len; i += sizeof(uint8x16_t), str += sizeof(uint8x16_t)) {
+        size += sizeof(uint8x16_t);
+
+        // See https://lemire.me/blog/2019/07/23/arbitrary-byte-to-byte-maps-using-arm-neon/
+        uint8x16_t chunk = vld1q_u8(str);
+
+        // Check to see if any of these bytes have the high bit set.
+        has_some_hibit = vorrq_u8(has_some_hibit, vandq_u8(chunk, hibit));
 
+        uint8x16_t tmp1   = vqtbl4q_u8(rails_friendly_chars_neon[0], chunk);
+        uint8x16_t tmp2   = vqtbl4q_u8(rails_friendly_chars_neon[1], veorq_u8(chunk, vdupq_n_u8(0x40)));
+        uint8x16_t result = vorrq_u8(tmp1, tmp2);
+        uint8_t    tmp    = vaddvq_u8(result);
+        size += tmp;
+    }
+
+    // 'hi' should be set if any of the bytes we processed have the high bit set. It doesn't matter which ones.
+    hi = vmaxvq_u8(has_some_hibit) != 0;
+
+    for (; i < len; str++, i++) {
+        size += rails_friendly_chars[*str] - '0';
+        hi |= *str & 0x80;
+    }
+    if (0 == hi) {
+        return size;
+    }
+    return -(size);
+#else
+    size_t i = len;
     for (; 0 < i; str++, i--) {
         size += rails_friendly_chars[*str];
         hi |= *str & 0x80;
@@ -210,9 +347,10 @@ inline static size_t rails_friendly_size(const uint8_t *str, size_t len) {
         return size - len * (size_t)'0';
     }
     return -(size - len * (size_t)'0');
+#endif /* HAVE_SIMD_NEON */
 }
 
-const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, int *lenp) {
+const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, size_t *lenp) {
     const char *str = NULL;
 
     if (AutoNan == opt) {
@@ -477,7 +615,7 @@ void oj_dump_time(VALUE obj, Out out, int withZone) {
 void oj_dump_ruby_time(VALUE obj, Out out) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_xml_time(VALUE obj, Out out) {
@@ -711,13 +849,13 @@ void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
         rb_encoding *enc = rb_enc_from_index(idx);
         obj              = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
-    oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(obj), RSTRING_LEN(obj), 0, 0, out);
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), RSTRING_LEN(s), 0, 0, out);
 }
 
 static void debug_raise(const char *orig, size_t cnt, int line) {
@@ -758,9 +896,49 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
     }
 }
 
+#ifdef HAVE_SIMD_NEON
+typedef struct _neon_match_result {
+    uint8x16_t needs_escape;
+    bool       has_some_hibit;
+    bool       do_unicode_validation;
+} neon_match_result;
+
+#if defined(__clang__) || defined(__GNUC__)
+#define FORCE_INLINE __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+
+static inline FORCE_INLINE neon_match_result
+neon_update(const char *str, uint8x16x4_t *cmap_neon, int neon_table_size, bool do_unicode_validation, bool has_hi) {
+    neon_match_result result = {.has_some_hibit = false, .do_unicode_validation = false};
+
+    uint8x16_t chunk    = vld1q_u8((const unsigned char *)str);
+    uint8x16_t tmp1     = vqtbl4q_u8(cmap_neon[0], chunk);
+    uint8x16_t tmp2     = vqtbl4q_u8(cmap_neon[1], veorq_u8(chunk, vdupq_n_u8(0x40)));
+    result.needs_escape = vorrq_u8(tmp1, tmp2);
+    if (neon_table_size > 2) {
+        uint8x16_t tmp3     = vqtbl4q_u8(cmap_neon[2], veorq_u8(chunk, vdupq_n_u8(0x80)));
+        uint8x16_t tmp4     = vqtbl4q_u8(cmap_neon[3], veorq_u8(chunk, vdupq_n_u8(0xc0)));
+        result.needs_escape = vorrq_u8(result.needs_escape, vorrq_u8(tmp4, tmp3));
+    }
+    if (has_hi && do_unicode_validation) {
+        uint8x16_t has_some_hibit    = vandq_u8(chunk, vdupq_n_u8(0x80));
+        result.has_some_hibit        = vmaxvq_u8(has_some_hibit) != 0;
+        result.do_unicode_validation = has_hi && do_unicode_validation && result.has_some_hibit;
+    }
+    return result;
+}
+
+#endif /* HAVE_SIMD_NEON */
+
 void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out out) {
-    size_t      size;
-    char       *cmap;
+    size_t size;
+    char  *cmap;
+#ifdef HAVE_SIMD_NEON
+    uint8x16x4_t *cmap_neon = NULL;
+    int           neon_table_size;
+#endif /* HAVE_SIMD_NEON */
     const char *orig                  = str;
     bool        has_hi                = false;
     bool        do_unicode_validation = false;
@@ -792,7 +970,11 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         long sz;
 
         cmap = rails_xss_friendly_chars;
-        sz   = rails_xss_friendly_size((uint8_t *)str, cnt);
+#ifdef HAVE_SIMD_NEON
+        cmap_neon       = rails_xss_friendly_chars_neon;
+        neon_table_size = 4;
+#endif /* HAVE_NEON_SIMD */
+        sz = rails_xss_friendly_size((uint8_t *)str, cnt);
         if (sz < 0) {
             has_hi = true;
             size   = (size_t)-sz;
@@ -805,7 +987,11 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
     case RailsEsc: {
         long sz;
         cmap = rails_friendly_chars;
-        sz   = rails_friendly_size((uint8_t *)str, cnt);
+#ifdef HAVE_SIMD_NEON
+        cmap_neon       = rails_friendly_chars_neon;
+        neon_table_size = 2;
+#endif /* HAVE_NEON_SIMD */
+        sz = rails_friendly_size((uint8_t *)str, cnt);
         if (sz < 0) {
             has_hi = true;
             size   = (size_t)-sz;
@@ -816,7 +1002,12 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         break;
     }
     case JSONEsc:
-    default: cmap = hibit_friendly_chars; size = hibit_friendly_size((uint8_t *)str, cnt);
+    default: cmap = hibit_friendly_chars;
+#ifdef HAVE_SIMD_NEON
+        cmap_neon       = hibit_friendly_chars_neon;
+        neon_table_size = 2;
+#endif /* HAVE_NEON_SIMD */
+        size = hibit_friendly_size((uint8_t *)str, cnt);
     }
     assure_size(out, size + BUFFER_EXTRA);
     *out->cur++ = '"';
@@ -842,8 +1033,116 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         if (is_sym) {
             *out->cur++ = ':';
         }
+#ifdef HAVE_SIMD_NEON
+        const char *chunk_start;
+        const char *chunk_end;
+        const char *cursor     = str;
+        int         neon_state = (cmap_neon != NULL) ? 1 : 4;
+        char        matches[16];
+        bool        do_hi_validation = false;
+        // uint64_t neon_match_mask = 0;
+#define SEARCH_FLUSH                                  \
+    if (str > cursor) {                               \
+        APPEND_CHARS(out->cur, cursor, str - cursor); \
+        cursor = str;                                 \
+    }
+
+    loop:
+#endif /* HAVE_SIMD_NEON */
         for (; str < end; str++) {
-            switch (cmap[(uint8_t)*str]) {
+            char action = 0;
+#ifdef HAVE_SIMD_NEON
+            /* neon_state:
+             * 1: Scanning for matches. There must be at least
+                  sizeof(uint8x16_t) bytes of input data to use SIMD and
+                  cmap_neon must be non-null.
+             * 2: Matches have been found. Will set str to the position of the
+             *    next match and set the state to 3.
+             *    If there are no more matches it will transition to state 1.
+             * 4: Fallback to the scalar algorithm. Not enough data to use
+             *    SIMD.
+             */
+#define NEON_SET_STATE(state) \
+    neon_state = state;       \
+    goto loop;
+#define NEON_RETURN_TO_STATE(state) neon_state = state;
+            switch (neon_state) {
+            case 1: {
+                while (true) {
+                    const char *chunk_ptr = NULL;
+                    if (str + sizeof(uint8x16_t) <= end) {
+                        chunk_ptr   = str;
+                        chunk_start = str;
+                        chunk_end   = str + sizeof(uint8x16_t);
+                    } else if ((end - str) >= SIMD_MINIMUM_THRESHOLD) {
+                        memset(out->cur, 'A', sizeof(uint8x16_t));
+                        memcpy(out->cur, str, (end - str));
+                        chunk_ptr   = out->cur;
+                        chunk_start = str;
+                        chunk_end   = end;
+                    } else {
+                        SEARCH_FLUSH;
+                        NEON_SET_STATE(4);
+                        break; /* Unreachable */
+                    }
+                    neon_match_result result = neon_update(chunk_ptr,
+                                                           cmap_neon,
+                                                           neon_table_size,
+                                                           do_unicode_validation,
+                                                           has_hi);
+                    if ((result.do_unicode_validation) || vmaxvq_u8(result.needs_escape) != 0) {
+                        SEARCH_FLUSH;
+                        uint8x16_t actions = vaddq_u8(result.needs_escape, vdupq_n_u8('1'));
+                        do_hi_validation   = result.do_unicode_validation;
+                        vst1q_u8((unsigned char *)matches, actions);
+                        NEON_SET_STATE(2);
+                        break; /* Unreachable */
+                    }
+                    str = chunk_end;
+                }
+                // We must have run out of data to use SIMD. Go to state 4.
+                SEARCH_FLUSH;
+                NEON_SET_STATE(4);
+            } break;
+            case 3:
+                cursor = str;
+                // This fall through is intentional. We return to state 3 after we process
+                // a byte (or multiple). We return to this state to ensure the cursor is
+                // pointing to the correct location. We then resume looking for matches
+                // within the previously processed chunk.
+            case 2:
+                if (str >= chunk_end) {
+                    NEON_SET_STATE(1);
+                }
+                if (!do_hi_validation) {
+                    long i = str - chunk_start;
+                    for (; str < chunk_end; i++) {
+                        if ((action = matches[i]) != '1') {
+                            break;
+                        }
+                        *out->cur++ = *str++;
+                    }
+                    // The loop above may have advanced str and directly output them to out->cur.
+                    // Ensure cursor is set appropriately.
+                    cursor = str;
+                    if (str >= chunk_end) {
+                        // We must have advanced past the end... we are done.
+                        NEON_SET_STATE(1);
+                    }
+                } else {
+                    long match_index = str - chunk_start;
+                    action           = matches[match_index];
+                }
+                NEON_RETURN_TO_STATE(3);
+                break;
+            case 4: action = cmap[(uint8_t)*str];
+            }
+#undef NEON_SET_STATE
+#undef NEON_RETURN_TO_STATE
+#else
+            action = cmap[(uint8_t)*str];
+#endif /* HAVE_SIMD_NEON */
+            switch (action) {
             case '1':
                 if (do_unicode_validation && check_start <= str) {
                     if (0 != (0x80 & (uint8_t)*str)) {
@@ -906,7 +1205,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         *out->cur++ = '"';
     }
     if (do_unicode_validation && 0 < str - orig && 0 != (0x80 & *(str - 1))) {
-        uint8_t c = (uint8_t) * (str - 1);
+        uint8_t c = (uint8_t)*(str - 1);
         int     i;
         int     scnt = (int)(str - orig);
 
@@ -957,7 +1256,7 @@ void oj_dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 void oj_dump_obj_to_s(VALUE obj, Out out) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_raw(const char *str, size_t cnt, Out out) {
@@ -1092,7 +1391,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
 
 void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE rs             = rb_big2str(obj, 10);
-    int            cnt            = (int)RSTRING_LEN(rs);
+    size_t         cnt            = RSTRING_LEN(rs);
     bool           dump_as_string = false;
 
     if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {  // Bignum cannot be inside of Fixnum range
@@ -1114,7 +1413,7 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char  *b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -1225,7 +1524,7 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     } else if (0 == out->opts->float_prec) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        cnt = (int)RSTRING_LEN(rstr);
+        cnt = RSTRING_LEN(rstr);
         if ((int)sizeof(buf) <= cnt) {
             cnt = sizeof(buf) - 1;
         }
@@ -1239,8 +1538,8 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     *out->cur = '\0';
 }
 
-int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format) {
-    int cnt = snprintf(buf, blen, format, d);
+size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format) {
+    size_t cnt = snprintf(buf, blen, format, d);
 
     // Round off issues at 16 significant digits so check for obvious ones of
     // 0001 and 9999.
@@ -1248,7 +1547,7 @@ int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
         strcpy(buf, RSTRING_PTR(rstr));
-        cnt = (int)RSTRING_LEN(rstr);
+        cnt = RSTRING_LEN(rstr);
     }
     return cnt;
 }

data/ext/oj/dump.h

@@ -7,12 +7,17 @@
 #include <ruby.h>
 
 #include "oj.h"
+#include "simd.h"
 
 #define MAX_DEPTH 1000
 
 // Extra padding at end of buffer.
 #define BUFFER_EXTRA 64
 
+#ifdef HAVE_SIMD_NEON
+extern void initialize_neon(void);
+#endif /* HAVE_SIMD_NEON */
+
 extern void oj_dump_nil(VALUE obj, int depth, Out out, bool as_ok);
 extern void oj_dump_true(VALUE obj, int depth, Out out, bool as_ok);
 extern void oj_dump_false(VALUE obj, int depth, Out out, bool as_ok);
@@ -30,7 +35,7 @@ extern void oj_dump_xml_time(VALUE obj, Out out);
 extern void oj_dump_time(VALUE obj, Out out, int withZone);
 extern void oj_dump_obj_to_s(VALUE obj, Out out);
 
-extern const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, int *lenp);
+extern const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, size_t *lenp);
 
 // initialize an out buffer with the provided stack allocated memory
 extern void oj_out_init(Out out);
@@ -53,7 +58,7 @@ extern void oj_dump_raw_json(VALUE obj, int depth, Out out);
 extern VALUE oj_add_to_json(int argc, VALUE *argv, VALUE self);
 extern VALUE oj_remove_to_json(int argc, VALUE *argv, VALUE self);
 
-extern int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format);
+extern size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format);
 
 extern time_t oj_sec_from_time_hard_way(VALUE obj);
 

data/ext/oj/dump_compat.c

@@ -103,7 +103,7 @@ static void dump_values_array(VALUE *values, int depth, Out out) {
 static void dump_to_json(VALUE obj, Out out) {
     volatile VALUE rs;
     const char    *s;
-    int            len;
+    size_t         len;
 
     TRACE(out->opts->trace, "to_json", obj, 0, TraceRubyIn);
     if (0 == rb_obj_method_arity(obj, oj_to_json_id)) {
@@ -115,7 +115,7 @@ static void dump_to_json(VALUE obj, Out out) {
 
     StringValue(rs);
     s   = RSTRING_PTR(rs);
-    len = (int)RSTRING_LEN(rs);
+    len = RSTRING_LEN(rs);
 
     assure_size(out, len + 1);
     APPEND_CHARS(out->cur, s, len);
@@ -124,7 +124,8 @@ static void dump_to_json(VALUE obj, Out out) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
     long   id = oj_check_circular(a, out);
 
@@ -136,7 +137,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         dump_to_json(a, out);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     assure_size(out, 2);
     if (0 == cnt) {
@@ -552,7 +553,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char  *b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -590,7 +591,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
         strcpy(buf, RSTRING_PTR(rstr));
-        cnt = (int)RSTRING_LEN(rstr);
+        cnt = RSTRING_LEN(rstr);
     }
     assure_size(out, cnt);
     APPEND_CHARS(out->cur, buf, cnt);
@@ -800,7 +801,7 @@ static void dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     // rb_big2str can not so unless overridden by using add_to_json(Integer)
     // this must use to_s to pass the json gem unit tests.
     volatile VALUE rs;
-    int            cnt;
+    size_t         cnt;
     bool           dump_as_string = false;
 
     if (use_bignum_alt) {
@@ -809,7 +810,7 @@ static void dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
         rs = oj_safe_string_convert(obj);
     }
     rb_check_type(rs, T_STRING);
-    cnt = (int)RSTRING_LEN(rs);
+    cnt = RSTRING_LEN(rs);
 
     if (out->opts->int_range_min != 0 || out->opts->int_range_max != 0) {
         dump_as_string = true;  // Bignum cannot be inside of Fixnum range

data/ext/oj/dump_leaf.c

@@ -17,7 +17,7 @@ inline static void dump_chars(const char *s, size_t size, Out out) {
 static void dump_leaf_str(Leaf leaf, Out out) {
     switch (leaf->value_type) {
     case STR_VAL: oj_dump_cstr(leaf->str, strlen(leaf->str), 0, 0, out); break;
-    case RUBY_VAL: oj_dump_cstr(StringValueCStr(leaf->value), (int)RSTRING_LEN(leaf->value), 0, 0, out); break;
+    case RUBY_VAL: oj_dump_cstr(StringValueCStr(leaf->value), RSTRING_LEN(leaf->value), 0, 0, out); break;
     case COL_VAL:
     default: rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type); break;
     }

data/ext/oj/dump_object.c

@@ -33,7 +33,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
         if (oj_bigdecimal_class == clas) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
             const char    *str  = RSTRING_PTR(rstr);
-            int            len  = (int)RSTRING_LEN(rstr);
+            size_t         len  = RSTRING_LEN(rstr);
 
             if (No != out->opts->bigdec_as_num) {
                 oj_dump_raw(str, len, out);
@@ -62,7 +62,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
         const char    *str  = RSTRING_PTR(rstr);
-        int            len  = (int)RSTRING_LEN(rstr);
+        size_t         len  = RSTRING_LEN(rstr);
 
         if (0 == strcasecmp("Infinity", str)) {
             str = oj_nan_str(obj, out->opts->dump_opts.nan_dump, out->opts->mode, true, &len);
@@ -95,7 +95,8 @@ static void dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
     long   id = oj_check_circular(a, out);
 
@@ -106,7 +107,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
         dump_obj_attrs(a, clas, 0, depth, out);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     if (0 < id) {
         assure_size(out, d2 * out->indent + 16);
@@ -181,7 +182,7 @@ static void dump_str_class(VALUE obj, VALUE clas, int depth, Out out) {
         dump_obj_attrs(obj, clas, 0, depth, out);
     } else {
         const char *s   = RSTRING_PTR(obj);
-        size_t      len = (int)RSTRING_LEN(obj);
+        size_t      len = RSTRING_LEN(obj);
         char        s1  = s[1];
 
         oj_dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
@@ -195,7 +196,7 @@ static void dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 1, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), RSTRING_LEN(s), 1, 0, out);
 }
 
 static int hash_cb(VALUE key, VALUE value, VALUE ov) {
@@ -389,7 +390,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.");
         } else {
             const char *s    = RSTRING_PTR(v);
-            int         len  = (int)RSTRING_LEN(v);
+            size_t      len  = RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
 
@@ -489,7 +490,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
         *out->cur++ = ',';
         fill_indent(out, d2);
         APPEND_CHARS(out->cur, "\"self\":", 7);
-        oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
+        oj_dump_cstr(RSTRING_PTR(obj), RSTRING_LEN(obj), 0, 0, out);
         break;
     case T_ARRAY:
         assure_size(out, d2 * out->indent + 14);
@@ -564,11 +565,12 @@ static void dump_regexp(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     VALUE       clas       = rb_obj_class(obj);
     const char *class_name = rb_class2name(clas);
-    int         i;
-    int         d2   = depth + 1;
-    int         d3   = d2 + 1;
-    size_t      len  = strlen(class_name);
-    size_t      size = d2 * out->indent + d3 * out->indent + 10 + len;
+    size_t      i;
+    int         d2       = depth + 1;
+    int         d3       = d2 + 1;
+    size_t      len      = strlen(class_name);
+    size_t      size     = d2 * out->indent + d3 * out->indent + 10 + len;
+    char        circular = out->opts->circular;
 
     assure_size(out, size);
     *out->cur++ = '{';
@@ -577,14 +579,14 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     if ('#' == *class_name) {
         VALUE       ma = rb_struct_s_members(clas);
         const char *name;
-        int         cnt = (int)RARRAY_LEN(ma);
+        size_t      cnt = RARRAY_LEN(ma);
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
             volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
             name = RSTRING_PTR(s);
-            len  = (int)RSTRING_LEN(s);
+            len  = RSTRING_LEN(s);
             size = len + 3;
             assure_size(out, size);
             if (0 < i) {
@@ -607,14 +609,18 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     {
         VALUE v;
         int   cnt;
+
 #if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
         cnt = (int)NUM2LONG(RSTRUCT_LEN(obj));
 #else   // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
         cnt = (int)RSTRUCT_LEN(obj);
 #endif  // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
 
-        for (i = 0; i < cnt; i++) {
-            v = RSTRUCT_GET(obj, i);
+        if (0 == strcmp(class_name, "Range")) {
+            out->opts->circular = 'n';
+        }
+        for (i = 0; i < (size_t)cnt; i++) {
+            v = RSTRUCT_GET(obj, (int)i);
             if (dump_ignore(out->opts, v)) {
                 v = Qnil;
             }
@@ -630,6 +636,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         // class in interpreted Ruby so length() may not be defined.
         int slen = FIX2INT(rb_funcall2(obj, oj_length_id, 0, 0));
 
+        if (0 == strcmp(class_name, "Range")) {
+            out->opts->circular = 'n';
+        }
         for (i = 0; i < slen; i++) {
             assure_size(out, size);
             fill_indent(out, d3);
@@ -641,6 +650,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         }
     }
 #endif
+    out->opts->circular = circular;
     out->cur--;
     APPEND_CHARS(out->cur, "]}", 2);
     *out->cur = '\0';

data/ext/oj/dump_strict.c

@@ -30,7 +30,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char*  b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -92,7 +92,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         } else if (0 == out->opts->float_prec) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
-            cnt = (int)RSTRING_LEN(rstr);
+            cnt = RSTRING_LEN(rstr);
             if ((int)sizeof(buf) <= cnt) {
                 cnt = sizeof(buf) - 1;
             }
@@ -109,7 +109,8 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
     if (Yes == out->opts->circular) {
@@ -118,7 +119,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);
@@ -290,7 +291,7 @@ static void dump_data_strict(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
     } else {
         raise_strict(obj);
     }
@@ -302,7 +303,7 @@ static void dump_data_null(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
     } else {
         oj_dump_nil(Qnil, depth, out, false);
     }

data/ext/oj/fast.c

@@ -1086,7 +1086,7 @@ static VALUE doc_open(VALUE clas, VALUE str) {
     int            given = rb_block_given_p();
 
     Check_Type(str, T_STRING);
-    len  = (int)RSTRING_LEN(str) + 1;
+    len  = RSTRING_LEN(str) + 1;
     json = OJ_R_ALLOC_N(char, len);
 
     memcpy(json, StringValuePtr(str), len);

data/ext/oj/object.c

@@ -305,7 +305,7 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
 
 static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE value) {
     if (T_ARRAY == rb_type(value)) {
-        int len = (int)RARRAY_LEN(value);
+        size_t len = RARRAY_LEN(value);
 
         if (2 == klen && 'u' == key[1]) {
             volatile VALUE sc;
@@ -321,19 +321,20 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
             if (T_ARRAY == rb_type(e1)) {
                 VALUE          args[1024];
                 volatile VALUE rstr;
-                int            i, cnt = (int)RARRAY_LEN(e1);
+                size_t         i;
+                size_t         cnt = RARRAY_LEN(e1);
 
                 for (i = 0; i < cnt; i++) {
                     rstr    = RARRAY_AREF(e1, i);
                     args[i] = rb_funcall(rstr, oj_to_sym_id, 0);
                 }
-                sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
+                sc = rb_funcall2(rb_cStruct, oj_new_id, (int)cnt, args);
             } else {
                 // If struct is not defined then we let this fail and raise an exception.
                 sc = oj_name2struct(pi, *RARRAY_CONST_PTR(value), rb_eArgError);
             }
             if (sc == rb_cRange) {
-                parent->val = rb_class_new_instance(len - 1, RARRAY_CONST_PTR(value) + 1, rb_cRange);
+                parent->val = rb_class_new_instance((int)(len - 1), RARRAY_CONST_PTR(value) + 1, rb_cRange);
             } else {
                 // Create a properly initialized struct instance without calling the initialize method.
                 parent->val = rb_obj_alloc(sc);
@@ -348,10 +349,10 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
 #endif
                 // MRI >= 1.9
-                if (len - 1 > slen) {
+                if (len - 1 > (size_t)slen) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
                 } else {
-                    int i;
+                    size_t i;
 
                     for (i = 0; i < len - 1; i++) {
                         rb_struct_aset(parent->val, INT2FIX(i), RARRAY_CONST_PTR(value)[i + 1]);
@@ -698,9 +699,8 @@ oj_object_parse(int argc, VALUE *argv, VALUE self) {
 
     if (T_STRING == rb_type(*argv)) {
         return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
-    } else {
-        return oj_pi_sparse(argc, argv, &pi, 0);
     }
+    return oj_pi_sparse(argc, argv, &pi, 0);
 }
 
 VALUE

data/ext/oj/oj.c

@@ -18,6 +18,7 @@
 #include "odd.h"
 #include "parse.h"
 #include "rails.h"
+#include "simd.h"
 
 typedef struct _yesNoOpt {
     VALUE sym;
@@ -923,12 +924,12 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         OJ_R_FREE(copts->ignore);
         copts->ignore = NULL;
         if (Qnil != v) {
-            int cnt;
+            size_t cnt;
 
             rb_check_type(v, T_ARRAY);
-            cnt = (int)RARRAY_LEN(v);
+            cnt = RARRAY_LEN(v);
             if (0 < cnt) {
-                int i;
+                size_t i;
 
                 copts->ignore = OJ_R_ALLOC_N(VALUE, cnt + 1);
                 for (i = 0; i < cnt; i++) {
@@ -973,7 +974,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (float_format_sym == k) {
         rb_check_type(v, T_STRING);
-        if (6 < (int)RSTRING_LEN(v)) {
+        if (6 < RSTRING_LEN(v)) {
             rb_raise(rb_eArgError, ":float_format must be 6 bytes or less.");
         }
         strncpy(copts->float_fmt, RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
@@ -1188,7 +1189,7 @@ static VALUE load_file(int argc, VALUE *argv, VALUE self) {
         OJ_FREE(wide_path);
     }
 #else
-    fd             = open(path, O_RDONLY);
+    fd = open(path, O_RDONLY);
 #endif
     if (0 == fd) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
@@ -2081,4 +2082,8 @@ void Init_oj(void) {
 
     oj_parser_init();
     oj_scanner_init();
+
+#ifdef HAVE_SIMD_NEON
+    initialize_neon();
+#endif /* HAVE_SIMD_NEON */
 }

data/ext/oj/rails.c

@@ -140,7 +140,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE v;
     int            cnt;
     int            i;
-    int            len;
+    size_t         len;
     const char    *name;
 
 #ifdef RSTRUCT_LEN
@@ -161,7 +161,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
         name = RSTRING_PTR(s);
-        len  = (int)RSTRING_LEN(s);
+        len  = RSTRING_LEN(s);
         assure_size(out, size + sep_len + 6);
         if (0 < i) {
             *out->cur++ = ',';
@@ -205,11 +205,11 @@ static void dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
     if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
         oj_dump_nil(Qnil, depth, out, false);
     } else if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     } else if (Yes == out->opts->bigdec_as_num) {
-        oj_dump_raw(str, (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(str, RSTRING_LEN(rstr), out);
     } else {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     }
 }
 
@@ -330,14 +330,14 @@ static void dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_to_s(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), 0, 0, out);
 }
 
 static ID parameters_id = 0;
 
 typedef struct _strLen {
     const char *str;
-    int         len;
+    size_t      len;
 } *StrLen;
 
 static void dump_actioncontroller_parameters(VALUE obj, int depth, Out out, bool as_ok) {
@@ -352,10 +352,10 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
     volatile VALUE v;
     StrLen         cp;
     StrLen         cols;
-    int            i;
-    int            cnt = (int)RARRAY_LEN(rcols);
+    size_t         i;
+    size_t         cnt = RARRAY_LEN(rcols);
 
-    *ccnt = cnt;
+    *ccnt = (int)cnt;
     cols  = OJ_R_ALLOC_N(struct _strLen, cnt);
     for (i = 0, cp = cols; i < cnt; i++, cp++) {
         v = RARRAY_AREF(rcols, i);
@@ -363,7 +363,7 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
             v = oj_safe_string_convert(v);
         }
         cp->str = StringValuePtr(v);
-        cp->len = (int)RSTRING_LEN(v);
+        cp->len = RSTRING_LEN(v);
     }
     return cols;
 }
@@ -424,7 +424,8 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     volatile VALUE rows;
     StrLen         cols;
     int            ccnt = 0;
-    int            i, rcnt;
+    size_t         i;
+    size_t         rcnt;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -435,7 +436,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     out->argc = 0;
     cols      = columns_array(rb_ivar_get(obj, columns_id), &ccnt);
     rows      = rb_ivar_get(obj, rows_id);
-    rcnt      = (int)RARRAY_LEN(rows);
+    rcnt      = RARRAY_LEN(rows);
     assure_size(out, 2);
     *out->cur++ = '[';
     if (out->opts->dump_opts.use) {
@@ -1173,7 +1174,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char  *b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -1194,7 +1195,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
             strcpy(buf, RSTRING_PTR(rstr));
-            cnt = (int)RSTRING_LEN(rstr);
+            cnt = RSTRING_LEN(rstr);
         }
     }
     assure_size(out, cnt);
@@ -1206,7 +1207,8 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
     if (Yes == out->opts->circular) {
@@ -1220,7 +1222,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         dump_as_json(a, depth, out, false);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);

data/ext/oj/simd.h

@@ -0,0 +1,10 @@
+#ifndef OJ_SIMD_H
+#define OJ_SIMD_H
+
+#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
+
+#endif /* OJ_SIMD_H */

data/ext/oj/wab.c

@@ -111,10 +111,11 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);
@@ -226,7 +227,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
     } else if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
 
-        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
     } else if (resolve_wab_uuid_class() == clas) {
         oj_dump_str(oj_safe_string_convert(obj), depth, out, false);
     } else if (resolve_uri_http_class() == clas) {

data/lib/oj/version.rb

@@ -1,4 +1,4 @@
 module Oj
   # Current version of the module.
-  VERSION = '3.16.10'
+  VERSION = '3.16.11'
 end

data/pages/Encoding.md

@@ -15,7 +15,7 @@ in a JSON document. The formatting follows these rules.
  * The `'^'` character denotes a special key value when in a JSON Object sequence.
 
  * A Ruby String that starts with `':'`or the sequence `'^i'` or `'^r'` are
-   encoded by excaping the first character so that it appears as `'\u005e'` or
+   encoded by escaping the first character so that it appears as `'\u005e'` or
    `'\u003a'` instead of `':'` or `'^'`.
 
  * A `"^c"` JSON Object key indicates the value should be converted to a Ruby

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.16.10
+  version: 3.16.11
 platform: ruby
 authors:
 - Peter Ohler
 bindir: bin
 cert_chain: []
-date: 2025-02-25 00:00:00.000000000 Z
+date: 2025-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -162,6 +162,7 @@ files:
 - ext/oj/saj2.c
 - ext/oj/saj2.h
 - ext/oj/scp.c
+- ext/oj/simd.h
 - ext/oj/sparse.c
 - ext/oj/stream_writer.c
 - ext/oj/strict.c