json 2.12.2 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b76bc749fd1bc82cd84df8c7d14317305d5426e0962d0e034864b218e952e474
-  data.tar.gz: 8e8d9179b6ca7ce69c7a281691973dc9cb1e6b147a5812b96d02c3b41d8f8cec
+  metadata.gz: 41dcbe399cb5dd00e62d93c87f31b356674c1feb9430306902009ebf8f56bd9a
+  data.tar.gz: f398e819143dc90c162474b5c97241d7a8c8c8209d5a5512c1b081d72a29192a
 SHA512:
-  metadata.gz: a241873428f8de2106604f3a31484aa243b6f62c6c6f38f8e381669f937b19f03b35add48ddf4f1d24c5a9f469c2dbdc8bafca36d8f3bcf678313ad8d9ea11d3
-  data.tar.gz: 99d07dbf3dcacda3cf662ee05bc181aa3ca6e43ce8779b9f5edc454fba8e718abe876eb81b4918e0c0bb1a3b4286e1d85df086425e552743420942a8e0098f0e
+  metadata.gz: ff828416dfb1f4a6ffcb51e02827d948b6c566ce008799cc9a02afb538b8d9a32ff1d6eee5c4e0e609757d1e9cfe1332ea359049a3fd820b199bdc7931a2573e
+  data.tar.gz: e5ea4c5bd447d2ed5c37b144219cd0cbed1474a5c7976f63b938996687cfc7f422e4e147582e6fee0a2d3f4ba09937496c23f08c42e2a525744a9246bcfcb5df

data/CHANGES.md

@@ -2,6 +2,12 @@
 
 ### Unreleased
 
+### 2025-05-23 (2.13.0)
+
+* Add new `allow_duplicate_key` parsing options. By default a warning is now emitted when a duplicated key is encountered.
+  In `json 3.0` an error will be raised.
+* Optimize parsing further using SIMD to scan strings.
+
 ### 2025-05-23 (2.12.2)
 
 * Fix compiler optimization level.

data/ext/json/ext/generator/extconf.rb

@@ -9,31 +9,7 @@ else
   $defs << "-DJSON_DEBUG" if ENV["JSON_DEBUG"]
 
   if enable_config('generator-use-simd', default=!ENV["JSON_DISABLE_SIMD"])
-    if RbConfig::CONFIG['host_cpu'] =~ /^(arm.*|aarch64.*)/
-      # Try to compile a small program using NEON instructions
-      if have_header('arm_neon.h')
-        have_type('uint8x16_t', headers=['arm_neon.h']) && try_compile(<<~'SRC')
-          #include <arm_neon.h>
-          int main() {
-              uint8x16_t test = vdupq_n_u8(32);
-              return 0;
-          }
-        SRC
-          $defs.push("-DJSON_ENABLE_SIMD")
-      end
-    end
-
-    if have_header('x86intrin.h') && have_type('__m128i', headers=['x86intrin.h']) && try_compile(<<~'SRC')
-      #include <x86intrin.h>
-      int main() {
-          __m128i test = _mm_set1_epi8(32);
-          return 0;
-      }
-      SRC
-        $defs.push("-DJSON_ENABLE_SIMD")
-    end
-
-    have_header('cpuid.h')
+    load __dir__ + "/../simd/conf.rb"
   end
 
   create_makefile 'json/ext/generator'

data/ext/json/ext/generator/generator.c

@@ -5,7 +5,7 @@
 #include <math.h>
 #include <ctype.h>
 
-#include "simd.h"
+#include "../simd/simd.h"
 
 /* ruby api and some helpers */
 
@@ -304,28 +304,6 @@ static inline FORCE_INLINE unsigned char neon_next_match(search_state *search)
     return 1;
 }
 
-// See: https://community.arm.com/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/porting-x86-vector-bitmask-optimizations-to-arm-neon
-static inline FORCE_INLINE uint64_t neon_match_mask(uint8x16_t matches)
-{
-    const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(matches), 4);
-    const uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
-    return mask & 0x8888888888888888ull;
-}
-
-static inline FORCE_INLINE uint64_t neon_rules_update(const char *ptr)
-{
-    uint8x16_t chunk = vld1q_u8((const unsigned char *)ptr);
-
-    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
-    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
-    const uint8x16_t too_low_or_dbl_quote = vcltq_u8(veorq_u8(chunk, vdupq_n_u8(2)), vdupq_n_u8(33));
-
-    uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
-    uint8x16_t needs_escape  = vorrq_u8(too_low_or_dbl_quote, has_backslash);
-
-    return neon_match_mask(needs_escape);
-}
-
 static inline unsigned char search_escape_basic_neon(search_state *search)
 {
     if (RB_UNLIKELY(search->has_matches)) {
@@ -333,7 +311,7 @@ static inline unsigned char search_escape_basic_neon(search_state *search)
         if (search->matches_mask > 0) {
             return neon_next_match(search);
         } else {
-            // neon_next_match will only advance search->ptr up to the last matching character. 
+            // neon_next_match will only advance search->ptr up to the last matching character.
             // Skip over any characters in the last chunk that occur after the last match.
             search->has_matches = false;
             search->ptr = search->chunk_end;
@@ -342,67 +320,61 @@ static inline unsigned char search_escape_basic_neon(search_state *search)
 
     /*
     * The code below implements an SIMD-based algorithm to determine if N bytes at a time
-    * need to be escaped. 
-    * 
+    * need to be escaped.
+    *
     * Assume the ptr = "Te\sting!" (the double quotes are included in the string)
-    * 
+    *
     * The explanation will be limited to the first 8 bytes of the string for simplicity. However
     * the vector insructions may work on larger vectors.
-    * 
+    *
     * First, we load three constants 'lower_bound', 'backslash' and 'dblquote" in vector registers.
-    * 
-    * lower_bound: [20 20 20 20 20 20 20 20] 
-    * backslash:   [5C 5C 5C 5C 5C 5C 5C 5C] 
-    * dblquote:    [22 22 22 22 22 22 22 22] 
-    * 
-    * Next we load the first chunk of the ptr: 
+    *
+    * lower_bound: [20 20 20 20 20 20 20 20]
+    * backslash:   [5C 5C 5C 5C 5C 5C 5C 5C]
+    * dblquote:    [22 22 22 22 22 22 22 22]
+    *
+    * Next we load the first chunk of the ptr:
     * [22 54 65 5C 73 74 69 6E] ("  T  e  \  s  t  i  n)
-    * 
+    *
     * First we check if any byte in chunk is less than 32 (0x20). This returns the following vector
     * as no bytes are less than 32 (0x20):
     * [0 0 0 0 0 0 0 0]
-    * 
+    *
     * Next, we check if any byte in chunk is equal to a backslash:
     * [0 0 0 FF 0 0 0 0]
-    * 
+    *
     * Finally we check if any byte in chunk is equal to a double quote:
-    * [FF 0 0 0 0 0 0 0] 
-    * 
+    * [FF 0 0 0 0 0 0 0]
+    *
     * Now we have three vectors where each byte indicates if the corresponding byte in chunk
     * needs to be escaped. We combine these vectors with a series of logical OR instructions.
     * This is the needs_escape vector and it is equal to:
-    * [FF 0 0 FF 0 0 0 0] 
-    * 
+    * [FF 0 0 FF 0 0 0 0]
+    *
     * Next we compute the bitwise AND between each byte and 0x1 and compute the horizontal sum of
     * the values in the vector. This computes how many bytes need to be escaped within this chunk.
-    * 
+    *
     * Finally we compute a mask that indicates which bytes need to be escaped. If the mask is 0 then,
     * no bytes need to be escaped and we can continue to the next chunk. If the mask is not 0 then we
     * have at least one byte that needs to be escaped.
     */
-    while (search->ptr + sizeof(uint8x16_t) <= search->end) {
-        uint64_t mask = neon_rules_update(search->ptr);
 
-        if (!mask) {
-            search->ptr += sizeof(uint8x16_t);
-            continue;
-        }
-        search->matches_mask = mask;
+    if (string_scan_simd_neon(&search->ptr, search->end, &search->matches_mask)) {
         search->has_matches = true;
         search->chunk_base = search->ptr;
         search->chunk_end = search->ptr + sizeof(uint8x16_t);
         return neon_next_match(search);
     }
 
-    // There are fewer than 16 bytes left. 
+    // There are fewer than 16 bytes left.
     unsigned long remaining = (search->end - search->ptr);
     if (remaining >= SIMD_MINIMUM_THRESHOLD) {
         char *s = copy_remaining_bytes(search, sizeof(uint8x16_t), remaining);
 
-        uint64_t mask = neon_rules_update(s);
+        uint64_t mask = compute_chunk_mask_neon(s);
 
         if (!mask) {
-            // Nothing to escape, ensure search_flush doesn't do anything by setting 
+            // Nothing to escape, ensure search_flush doesn't do anything by setting
             // search->cursor to search->ptr.
             fbuffer_consumed(search->buffer, remaining);
             search->ptr = search->end;
@@ -428,11 +400,6 @@ static inline unsigned char search_escape_basic_neon(search_state *search)
 
 #ifdef HAVE_SIMD_SSE2
 
-#define _mm_cmpge_epu8(a, b) _mm_cmpeq_epi8(_mm_max_epu8(a, b), a)
-#define _mm_cmple_epu8(a, b) _mm_cmpge_epu8(b, a)
-#define _mm_cmpgt_epu8(a, b) _mm_xor_si128(_mm_cmple_epu8(a, b), _mm_set1_epi8(-1))
-#define _mm_cmplt_epu8(a, b) _mm_cmpgt_epu8(b, a)
-
 static inline FORCE_INLINE unsigned char sse2_next_match(search_state *search)
 {
     int mask = search->matches_mask;
@@ -457,18 +424,6 @@ static inline FORCE_INLINE unsigned char sse2_next_match(search_state *search)
 #define TARGET_SSE2
 #endif
 
-static inline TARGET_SSE2 FORCE_INLINE int sse2_update(const char *ptr)
-{
-    __m128i chunk         = _mm_loadu_si128((__m128i const*)ptr);
-
-    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
-    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
-    __m128i too_low_or_dbl_quote = _mm_cmplt_epu8(_mm_xor_si128(chunk, _mm_set1_epi8(2)), _mm_set1_epi8(33));
-    __m128i has_backslash = _mm_cmpeq_epi8(chunk, _mm_set1_epi8('\\'));
-    __m128i needs_escape  = _mm_or_si128(too_low_or_dbl_quote, has_backslash);
-    return _mm_movemask_epi8(needs_escape);
-}
-
 static inline TARGET_SSE2 FORCE_INLINE unsigned char search_escape_basic_sse2(search_state *search)
 {
     if (RB_UNLIKELY(search->has_matches)) {
@@ -476,7 +431,7 @@ static inline TARGET_SSE2 FORCE_INLINE unsigned char search_escape_basic_sse2(se
         if (search->matches_mask > 0) {
             return sse2_next_match(search);
         } else {
-            // sse2_next_match will only advance search->ptr up to the last matching character. 
+            // sse2_next_match will only advance search->ptr up to the last matching character.
             // Skip over any characters in the last chunk that occur after the last match.
             search->has_matches = false;
             if (RB_UNLIKELY(search->chunk_base + sizeof(__m128i) >= search->end)) {
@@ -487,29 +442,22 @@ static inline TARGET_SSE2 FORCE_INLINE unsigned char search_escape_basic_sse2(se
         }
     }
 
-    while (search->ptr + sizeof(__m128i) <= search->end) {
-        int needs_escape_mask = sse2_update(search->ptr);
-
-        if (needs_escape_mask == 0) {
-            search->ptr += sizeof(__m128i);
-            continue;
-        }
-
+    if (string_scan_simd_sse2(&search->ptr, search->end, &search->matches_mask)) {
         search->has_matches = true;
-        search->matches_mask = needs_escape_mask;
         search->chunk_base = search->ptr;
+        search->chunk_end = search->ptr + sizeof(__m128i);
         return sse2_next_match(search);
     }
 
-    // There are fewer than 16 bytes left. 
+    // There are fewer than 16 bytes left.
     unsigned long remaining = (search->end - search->ptr);
     if (remaining >= SIMD_MINIMUM_THRESHOLD) {
         char *s = copy_remaining_bytes(search, sizeof(__m128i), remaining);
 
-        int needs_escape_mask = sse2_update(s);
+        int needs_escape_mask = compute_chunk_mask_sse2(s);
 
         if (needs_escape_mask == 0) {
-            // Nothing to escape, ensure search_flush doesn't do anything by setting 
+            // Nothing to escape, ensure search_flush doesn't do anything by setting
             // search->cursor to search->ptr.
             fbuffer_consumed(search->buffer, remaining);
             search->ptr = search->end;
@@ -638,7 +586,8 @@ static inline unsigned char search_ascii_only_escape(search_state *search, const
     return 0;
 }
 
-static inline void full_escape_UTF8_char(search_state *search, unsigned char ch_len) {
+static inline void full_escape_UTF8_char(search_state *search, unsigned char ch_len)
+{
     const unsigned char ch = (unsigned char)*search->ptr;
     switch (ch_len) {
         case 1: {
@@ -668,7 +617,7 @@ static inline void full_escape_UTF8_char(search_state *search, unsigned char ch_
 
             uint32_t wchar = 0;
 
-            switch(ch_len) {
+            switch (ch_len) {
                 case 2:
                     wchar = ch & 0x1F;
                     break;
@@ -828,7 +777,8 @@ static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self)
  * _state_ is a JSON::State object, that can also be used to configure the
  * produced JSON string output further.
  */
-static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
+static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self)
+{
     rb_check_arity(argc, 0, 1);
     VALUE Vstate = cState_from_state_s(cState, argc == 1 ? argv[0] : Qnil);
     return cState_partial_generate(Vstate, self, generate_json_array, Qfalse);
@@ -890,7 +840,8 @@ static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
  *
  * Extends _modul_ with the String::Extend module.
  */
-static VALUE mString_included_s(VALUE self, VALUE modul) {
+static VALUE mString_included_s(VALUE self, VALUE modul)
+{
     VALUE result = rb_funcall(modul, i_extend, 1, mString_Extend);
     rb_call_super(1, &modul);
     return result;
@@ -1135,7 +1086,7 @@ json_object_i(VALUE key, VALUE val, VALUE _arg)
     }
 
     VALUE key_to_s;
-    switch(rb_type(key)) {
+    switch (rb_type(key)) {
         case T_STRING:
             if (RB_LIKELY(RBASIC_CLASS(key) == rb_cString)) {
                 key_to_s = key;
@@ -1219,7 +1170,7 @@ static void generate_json_array(FBuffer *buffer, struct generate_json_data *data
 
     fbuffer_append_char(buffer, '[');
     if (RB_UNLIKELY(data->state->array_nl)) fbuffer_append_str(buffer, data->state->array_nl);
-    for(i = 0; i < RARRAY_LEN(obj); i++) {
+    for (i = 0; i < RARRAY_LEN(obj); i++) {
         if (i > 0) {
             fbuffer_append_char(buffer, ',');
             if (RB_UNLIKELY(data->state->array_nl)) fbuffer_append_str(buffer, data->state->array_nl);
@@ -1304,7 +1255,7 @@ static void generate_json_string(FBuffer *buffer, struct generate_json_data *dat
     search.chunk_base = NULL;
 #endif /* HAVE_SIMD */
 
-    switch(rb_enc_str_coderange(obj)) {
+    switch (rb_enc_str_coderange(obj)) {
         case ENC_CODERANGE_7BIT:
         case ENC_CODERANGE_VALID:
             if (RB_UNLIKELY(data->state->ascii_only)) {
@@ -2168,7 +2119,7 @@ void Init_generator(void)
     rb_require("json/ext/generator/state");
 
 
-    switch(find_simd_implementation()) {
+    switch (find_simd_implementation()) {
 #ifdef HAVE_SIMD
 #ifdef HAVE_SIMD_NEON
         case SIMD_NEON:

data/ext/json/ext/parser/extconf.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 require 'mkmf'
 
-have_func("rb_enc_interned_str", "ruby.h") # RUBY_VERSION >= 3.0
+have_func("rb_enc_interned_str", "ruby/encoding.h") # RUBY_VERSION >= 3.0
 have_func("rb_hash_new_capa", "ruby.h") # RUBY_VERSION >= 3.2
 have_func("rb_hash_bulk_insert", "ruby.h") # Missing on TruffleRuby
 have_func("strnlen", "string.h") # Missing on Solaris 10
 
 append_cflags("-std=c99")
 
+if enable_config('parser-use-simd', default=!ENV["JSON_DISABLE_SIMD"])
+  load __dir__ + "/../simd/conf.rb"
+end
+
 create_makefile 'json/ext/parser'

data/ext/json/ext/parser/parser.c

@@ -20,6 +20,8 @@ typedef unsigned char _Bool;
 #endif
 #endif
 
+#include "../simd/simd.h"
+
 #ifndef RB_UNLIKELY
 #define RB_UNLIKELY(expr) expr
 #endif
@@ -35,7 +37,7 @@ static ID i_chr, i_aset, i_aref,
           i_leftshift, i_new, i_try_convert, i_uminus, i_encode;
 
 static VALUE sym_max_nesting, sym_allow_nan, sym_allow_trailing_comma, sym_symbolize_names, sym_freeze,
-             sym_decimal_class, sym_on_load;
+             sym_decimal_class, sym_on_load, sym_allow_duplicate_key;
 
 static int binary_encindex;
 static int utf8_encindex;
@@ -363,10 +365,17 @@ static int convert_UTF32_to_UTF8(char *buf, uint32_t ch)
     return len;
 }
 
+enum duplicate_key_action {
+    JSON_DEPRECATED = 0,
+    JSON_IGNORE,
+    JSON_RAISE,
+};
+
 typedef struct JSON_ParserStruct {
     VALUE on_load_proc;
     VALUE decimal_class;
     ID decimal_method_id;
+    enum duplicate_key_action on_duplicate_key;
     int max_nesting;
     bool allow_nan;
     bool allow_trailing_comma;
@@ -386,15 +395,8 @@ typedef struct JSON_ParserStateStruct {
     int current_nesting;
 } JSON_ParserState;
 
-
-#define PARSE_ERROR_FRAGMENT_LEN 32
-#ifdef RBIMPL_ATTR_NORETURN
-RBIMPL_ATTR_NORETURN()
-#endif
-static void raise_parse_error(const char *format, JSON_ParserState *state)
+static void cursor_position(JSON_ParserState *state, long *line_out, long *column_out)
 {
-    unsigned char buffer[PARSE_ERROR_FRAGMENT_LEN + 3];
-
     const char *cursor = state->cursor;
     long column = 0;
     long line = 1;
@@ -411,6 +413,27 @@ static void raise_parse_error(const char *format, JSON_ParserState *state)
             line++;
         }
     }
+    *line_out = line;
+    *column_out = column;
+}
+
+static void emit_parse_warning(const char *message, JSON_ParserState *state)
+{
+    long line, column;
+    cursor_position(state, &line, &column);
+
+    rb_warn("%s at line %ld column %ld", message, line, column);
+}
+
+#define PARSE_ERROR_FRAGMENT_LEN 32
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_parse_error(const char *format, JSON_ParserState *state)
+{
+    unsigned char buffer[PARSE_ERROR_FRAGMENT_LEN + 3];
+    long line, column;
+    cursor_position(state, &line, &column);
 
     const char *ptr = "EOF";
     if (state->cursor && state->cursor < state->end) {
@@ -517,7 +540,7 @@ static void
 json_eat_comments(JSON_ParserState *state)
 {
     if (state->cursor + 1 < state->end) {
-        switch(state->cursor[1]) {
+        switch (state->cursor[1]) {
             case '/': {
                 state->cursor = memchr(state->cursor, '\n', state->end - state->cursor);
                 if (!state->cursor) {
@@ -807,11 +830,25 @@ static inline VALUE json_decode_array(JSON_ParserState *state, JSON_ParserConfig
     return array;
 }
 
-static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, long count)
+static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, size_t count)
 {
-    VALUE object = rb_hash_new_capa(count);
+    size_t entries_count = count / 2;
+    VALUE object = rb_hash_new_capa(entries_count);
     rb_hash_bulk_insert(count, rvalue_stack_peek(state->stack, count), object);
 
+    if (RB_UNLIKELY(RHASH_SIZE(object) < entries_count)) {
+        switch (config->on_duplicate_key) {
+            case JSON_IGNORE:
+                break;
+            case JSON_DEPRECATED:
+                emit_parse_warning("detected duplicate keys in JSON object. This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`", state);
+                break;
+            case JSON_RAISE:
+                raise_parse_error("duplicate key", state);
+                break;
+        }
+    }
+
     rvalue_stack_pop(state->stack, count);
 
     if (config->freeze) {
@@ -844,7 +881,7 @@ static inline VALUE json_push_value(JSON_ParserState *state, JSON_ParserConfig *
     return value;
 }
 
-static const bool string_scan[256] = {
+static const bool string_scan_table[256] = {
     // ASCII Control Characters
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -857,32 +894,71 @@ static const bool string_scan[256] = {
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 
+#if (defined(__GNUC__ ) || defined(__clang__))
+#define FORCE_INLINE __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+
+#ifdef HAVE_SIMD
+static SIMD_Implementation simd_impl = SIMD_NONE;
+#endif /* HAVE_SIMD */
+
+static inline bool FORCE_INLINE string_scan(JSON_ParserState *state)
+{
+#ifdef HAVE_SIMD
+#if defined(HAVE_SIMD_NEON)
+
+    uint64_t mask = 0;
+    if (string_scan_simd_neon(&state->cursor, state->end, &mask)) {
+        state->cursor += trailing_zeros64(mask) >> 2;
+        return 1;
+    }
+
+#elif defined(HAVE_SIMD_SSE2)
+    if (simd_impl == SIMD_SSE2) {
+        int mask = 0;
+        if (string_scan_simd_sse2(&state->cursor, state->end, &mask)) {
+            state->cursor += trailing_zeros(mask);
+            return 1;
+        }
+    }
+#endif /* HAVE_SIMD_NEON or HAVE_SIMD_SSE2 */
+#endif /* HAVE_SIMD */
+
+    while (state->cursor < state->end) {
+        if (RB_UNLIKELY(string_scan_table[(unsigned char)*state->cursor])) {
+            return 1;
+        }
+        *state->cursor++;
+    }
+    return 0;
+}
+
 static inline VALUE json_parse_string(JSON_ParserState *state, JSON_ParserConfig *config, bool is_name)
 {
     state->cursor++;
     const char *start = state->cursor;
     bool escaped = false;
 
-    while (state->cursor < state->end) {
-        if (RB_UNLIKELY(string_scan[(unsigned char)*state->cursor])) {
-            switch (*state->cursor) {
-                case '"': {
-                    VALUE string = json_decode_string(state, config, start, state->cursor, escaped, is_name);
-                    state->cursor++;
-                    return json_push_value(state, config, string);
-                }
-                case '\\': {
-                    state->cursor++;
-                    escaped = true;
-                    if ((unsigned char)*state->cursor < 0x20) {
-                        raise_parse_error("invalid ASCII control character in string: %s", state);
-                    }
-                    break;
-                }
-                default:
+    while (RB_UNLIKELY(string_scan(state))) {
+        switch (*state->cursor) {
+            case '"': {
+                VALUE string = json_decode_string(state, config, start, state->cursor, escaped, is_name);
+                state->cursor++;
+                return json_push_value(state, config, string);
+            }
+            case '\\': {
+                state->cursor++;
+                escaped = true;
+                if ((unsigned char)*state->cursor < 0x20) {
                     raise_parse_error("invalid ASCII control character in string: %s", state);
-                    break;
+                }
+                break;
             }
+            default:
+                raise_parse_error("invalid ASCII control character in string: %s", state);
+                break;
         }
 
         state->cursor++;
@@ -1060,6 +1136,8 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             break;
         }
         case '{': {
+            const char *object_start_cursor = state->cursor;
+
             state->cursor++;
             json_eat_whitespace(state);
             long stack_head = state->stack->head;
@@ -1094,8 +1172,15 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
                     if (*state->cursor == '}') {
                         state->cursor++;
                         state->current_nesting--;
-                        long count = state->stack->head - stack_head;
-                        return json_push_value(state, config, json_decode_object(state, config, count));
+                        size_t count = state->stack->head - stack_head;
+
+                        // Temporary rewind cursor in case an error is raised
+                        const char *final_cursor = state->cursor;
+                        state->cursor = object_start_cursor;
+                        VALUE object = json_decode_object(state, config, count);
+                        state->cursor = final_cursor;
+
+                        return json_push_value(state, config, object);
                     }
 
                     if (*state->cursor == ',') {
@@ -1184,6 +1269,7 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
     else if (key == sym_symbolize_names)      { config->symbolize_names = RTEST(val); }
     else if (key == sym_freeze)               { config->freeze = RTEST(val); }
     else if (key == sym_on_load)              { config->on_load_proc = RTEST(val) ? val : Qfalse; }
+    else if (key == sym_allow_duplicate_key) { config->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
     else if (key == sym_decimal_class)        {
         if (RTEST(val)) {
             if (rb_respond_to(val, i_try_convert)) {
@@ -1400,6 +1486,7 @@ void Init_parser(void)
     sym_freeze = ID2SYM(rb_intern("freeze"));
     sym_on_load = ID2SYM(rb_intern("on_load"));
     sym_decimal_class = ID2SYM(rb_intern("decimal_class"));
+    sym_allow_duplicate_key = ID2SYM(rb_intern("allow_duplicate_key"));
 
     i_chr = rb_intern("chr");
     i_aset = rb_intern("[]=");
@@ -1413,4 +1500,8 @@ void Init_parser(void)
     binary_encindex = rb_ascii8bit_encindex();
     utf8_encindex = rb_utf8_encindex();
     enc_utf8 = rb_utf8_encoding();
+
+#ifdef HAVE_SIMD
+    simd_impl = find_simd_implementation();
+#endif
 }

data/ext/json/ext/simd/conf.rb

@@ -0,0 +1,20 @@
+case RbConfig::CONFIG['host_cpu']
+when /^(arm|aarch64)/
+  # Try to compile a small program using NEON instructions
+  header, type, init = 'arm_neon.h', 'uint8x16_t', 'vdupq_n_u8(32)'
+when /^(x86_64|x64)/
+  header, type, init = 'x86intrin.h', '__m128i', '_mm_set1_epi8(32)'
+end
+if header
+  have_header(header) && try_compile(<<~SRC)
+    #{cpp_include(header)}
+    int main(int argc, char **argv) {
+      #{type} test = #{init};
+      if (argc > 100000) printf("%p", &test);
+      return 0;
+    }
+  SRC
+  $defs.push("-DJSON_ENABLE_SIMD")
+end
+
+have_header('cpuid.h')

data/ext/json/ext/simd/simd.h

@@ -0,0 +1,187 @@
+typedef enum {
+    SIMD_NONE,
+    SIMD_NEON,
+    SIMD_SSE2
+} SIMD_Implementation;
+
+#ifdef JSON_ENABLE_SIMD
+
+#ifdef __clang__
+  #if __has_builtin(__builtin_ctzll)
+    #define HAVE_BUILTIN_CTZLL 1
+  #else
+    #define HAVE_BUILTIN_CTZLL 0
+  #endif
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+  #define HAVE_BUILTIN_CTZLL 1
+#else
+  #define HAVE_BUILTIN_CTZLL 0
+#endif
+
+static inline uint32_t trailing_zeros64(uint64_t input)
+{
+#if HAVE_BUILTIN_CTZLL
+  return __builtin_ctzll(input);
+#else
+  uint32_t trailing_zeros = 0;
+  uint64_t temp = input;
+  while ((temp & 1) == 0 && temp > 0) {
+    trailing_zeros++;
+    temp >>= 1;
+  }
+  return trailing_zeros;
+#endif
+}
+
+static inline int trailing_zeros(int input)
+{
+  #if HAVE_BUILTIN_CTZLL
+    return __builtin_ctz(input);
+  #else
+    int trailing_zeros = 0;
+    int temp = input;
+    while ((temp & 1) == 0 && temp > 0) {
+      trailing_zeros++;
+      temp >>= 1;
+    }
+    return trailing_zeros;
+  #endif
+}
+
+#if (defined(__GNUC__ ) || defined(__clang__))
+#define FORCE_INLINE __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+
+
+#define SIMD_MINIMUM_THRESHOLD 6
+
+#if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM64)
+#include <arm_neon.h>
+
+#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
+static inline SIMD_Implementation find_simd_implementation(void)
+{
+    return SIMD_NEON;
+}
+
+#define HAVE_SIMD 1
+#define HAVE_SIMD_NEON 1
+
+// See: https://community.arm.com/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/porting-x86-vector-bitmask-optimizations-to-arm-neon
+static inline FORCE_INLINE uint64_t neon_match_mask(uint8x16_t matches)
+{
+    const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(matches), 4);
+    const uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+    return mask & 0x8888888888888888ull;
+}
+
+static inline FORCE_INLINE uint64_t compute_chunk_mask_neon(const char *ptr)
+{
+  uint8x16_t chunk = vld1q_u8((const unsigned char *)ptr);
+
+  // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
+  // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
+  const uint8x16_t too_low_or_dbl_quote = vcltq_u8(veorq_u8(chunk, vdupq_n_u8(2)), vdupq_n_u8(33));
+
+  uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
+  uint8x16_t needs_escape  = vorrq_u8(too_low_or_dbl_quote, has_backslash);
+  return neon_match_mask(needs_escape);
+}
+
+static inline FORCE_INLINE int string_scan_simd_neon(const char **ptr, const char *end, uint64_t *mask)
+{
+    while (*ptr + sizeof(uint8x16_t) <= end) {
+      uint64_t chunk_mask = compute_chunk_mask_neon(*ptr);
+      if (chunk_mask) {
+          *mask = chunk_mask;
+          return 1;
+      }
+      *ptr += sizeof(uint8x16_t);
+    }
+    return 0;
+}
+
+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;
+}
+
+#endif /* ARM Neon Support.*/
+
+#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
+
+#ifdef HAVE_X86INTRIN_H
+#include <x86intrin.h>
+
+#define HAVE_SIMD 1
+#define HAVE_SIMD_SSE2 1
+
+#ifdef HAVE_CPUID_H
+#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
+
+#if defined(__clang__) || defined(__GNUC__)
+#define TARGET_SSE2 __attribute__((target("sse2")))
+#else
+#define TARGET_SSE2
+#endif
+
+#define _mm_cmpge_epu8(a, b) _mm_cmpeq_epi8(_mm_max_epu8(a, b), a)
+#define _mm_cmple_epu8(a, b) _mm_cmpge_epu8(b, a)
+#define _mm_cmpgt_epu8(a, b) _mm_xor_si128(_mm_cmple_epu8(a, b), _mm_set1_epi8(-1))
+#define _mm_cmplt_epu8(a, b) _mm_cmpgt_epu8(b, a)
+
+static inline TARGET_SSE2 FORCE_INLINE int compute_chunk_mask_sse2(const char *ptr)
+{
+    __m128i chunk         = _mm_loadu_si128((__m128i const*)ptr);
+    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
+    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
+    __m128i too_low_or_dbl_quote = _mm_cmplt_epu8(_mm_xor_si128(chunk, _mm_set1_epi8(2)), _mm_set1_epi8(33));
+    __m128i has_backslash = _mm_cmpeq_epi8(chunk, _mm_set1_epi8('\\'));
+    __m128i needs_escape  = _mm_or_si128(too_low_or_dbl_quote, has_backslash);
+    return _mm_movemask_epi8(needs_escape);
+}
+
+static inline TARGET_SSE2 FORCE_INLINE int string_scan_simd_sse2(const char **ptr, const char *end, int *mask)
+{
+    while (*ptr + sizeof(__m128i) <= end) {
+      int chunk_mask = compute_chunk_mask_sse2(*ptr);
+      if (chunk_mask) {
+          *mask = chunk_mask;
+          return 1;
+      }
+      *ptr += sizeof(__m128i);
+    }
+
+    return 0;
+}
+
+#include <cpuid.h>
+#endif /* HAVE_CPUID_H */
+
+static inline SIMD_Implementation find_simd_implementation(void)
+{
+    // TODO Revisit. I think the SSE version now only uses SSE2 instructions.
+    if (__builtin_cpu_supports("sse2")) {
+        return SIMD_SSE2;
+    }
+
+    return SIMD_NONE;
+}
+
+#endif /* HAVE_X86INTRIN_H */
+#endif /* X86_64 Support */
+
+#endif /* JSON_ENABLE_SIMD */
+
+#ifndef FIND_SIMD_IMPLEMENTATION_DEFINED
+static inline SIMD_Implementation find_simd_implementation(void)
+{
+    return SIMD_NONE;
+}
+#endif

data/json.gemspec

@@ -44,15 +44,14 @@ spec = Gem::Specification.new do |s|
     "LEGAL",
     "README.md",
     "json.gemspec",
-    *Dir["lib/**/*.rb"],
-  ]
+  ] + Dir.glob("lib/**/*.rb", base: File.expand_path("..", __FILE__))
 
   if java_ext
     s.platform = 'java'
     s.files += Dir["lib/json/ext/**/*.jar"]
   else
     s.extensions = Dir["ext/json/**/extconf.rb"]
-    s.files += Dir["ext/json/**/*.{c,h}"]
+    s.files += Dir["ext/json/**/*.{c,h,rb}"]
   end
 end
 

data/lib/json/common.rb

@@ -268,7 +268,7 @@ module JSON
   # to string interpolation.
   #
   # Note: no validation is performed on the provided string. It is the
-  # responsability of the caller to ensure the string contains valid JSON.
+  # responsibility of the caller to ensure the string contains valid JSON.
   Fragment = Struct.new(:json) do
     def initialize(json)
       unless string = String.try_convert(json)

data/lib/json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSON
-  VERSION = '2.12.2'
+  VERSION = '2.13.0'
 end

data/lib/json.rb

@@ -127,6 +127,24 @@ require 'json/common'
 #
 # ---
 #
+# Option +allow_duplicate_key+ specifies whether duplicate keys in objects
+# should be ignored or cause an error to be raised:
+#
+# When not specified:
+#   # The last value is used and a deprecation warning emitted.
+#   JSON.parse('{"a": 1, "a":2}') => {"a" => 2}
+#   # waring: detected duplicate keys in JSON object.
+#   # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
+#
+# When set to `+true+`
+#   # The last value is used.
+#   JSON.parse('{"a": 1, "a":2}') => {"a" => 2}
+#
+# When set to `+false+`, the future default:
+#   JSON.parse('{"a": 1, "a":2}') => duplicate key at line 1 column 1 (JSON::ParserError)
+#
+# ---
+#
 # Option +allow_nan+ (boolean) specifies whether to allow
 # NaN, Infinity, and MinusInfinity in +source+;
 # defaults to +false+.
@@ -143,8 +161,23 @@ require 'json/common'
 #   ruby = JSON.parse(source, {allow_nan: true})
 #   ruby # => [NaN, Infinity, -Infinity]
 #
+# ---
+#
+# Option +allow_trailing_comma+ (boolean) specifies whether to allow
+# trailing commas in objects and arrays;
+# defaults to +false+.
+#
+# With the default, +false+:
+#   JSON.parse('[1,]') # unexpected character: ']' at line 1 column 4 (JSON::ParserError)
+#
+# When enabled:
+#   JSON.parse('[1,]', allow_trailing_comma: true) # => [1]
+#
 # ====== Output Options
 #
+# Option +freeze+ (boolean) specifies whether the returned objects will be frozen;
+# defaults to +false+.
+#
 # Option +symbolize_names+ (boolean) specifies whether returned \Hash keys
 # should be Symbols;
 # defaults to +false+ (use Strings).

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.12.2
+  version: 2.13.0
 platform: ruby
 authors:
 - Florian Frank
 bindir: bin
 cert_chain: []
-date: 2025-05-23 00:00:00.000000000 Z
+date: 2025-07-17 00:00:00.000000000 Z
 dependencies: []
 description: This is a JSON implementation as a Ruby extension in C.
 email: flori@ping.de
@@ -26,9 +26,10 @@ files:
 - ext/json/ext/fbuffer/fbuffer.h
 - ext/json/ext/generator/extconf.rb
 - ext/json/ext/generator/generator.c
-- ext/json/ext/generator/simd.h
 - ext/json/ext/parser/extconf.rb
 - ext/json/ext/parser/parser.c
+- ext/json/ext/simd/conf.rb
+- ext/json/ext/simd/simd.h
 - ext/json/ext/vendor/fpconv.c
 - ext/json/ext/vendor/jeaiii-ltoa.h
 - json.gemspec

data/ext/json/ext/generator/simd.h

@@ -1,112 +0,0 @@
-typedef enum {
-    SIMD_NONE,
-    SIMD_NEON,
-    SIMD_SSE2
-} SIMD_Implementation;
-
-#ifdef JSON_ENABLE_SIMD
-
-#ifdef __clang__
-  #if __has_builtin(__builtin_ctzll)
-    #define HAVE_BUILTIN_CTZLL 1
-  #else
-    #define HAVE_BUILTIN_CTZLL 0
-  #endif
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-  #define HAVE_BUILTIN_CTZLL 1
-#else
-  #define HAVE_BUILTIN_CTZLL 0
-#endif
-
-static inline uint32_t trailing_zeros64(uint64_t input) {
-#if HAVE_BUILTIN_CTZLL
-  return __builtin_ctzll(input);
-#else
-  uint32_t trailing_zeros = 0;
-  uint64_t temp = input;
-  while ((temp & 1) == 0 && temp > 0) {
-    trailing_zeros++;
-    temp >>= 1;
-  }
-  return trailing_zeros;
-#endif
-}
-
-static inline int trailing_zeros(int input) {
-  #if HAVE_BUILTIN_CTZLL
-    return __builtin_ctz(input);
-  #else
-    int trailing_zeros = 0;
-    int temp = input;
-    while ((temp & 1) == 0 && temp > 0) {
-      trailing_zeros++;
-      temp >>= 1;
-    }
-    return trailing_zeros;
-  #endif
-}
-
-#define SIMD_MINIMUM_THRESHOLD 6
-
-#if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM64)
-#include <arm_neon.h>
-
-#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
-static SIMD_Implementation find_simd_implementation(void) {
-    return SIMD_NEON;
-}
-
-#define HAVE_SIMD 1
-#define HAVE_SIMD_NEON 1
-
-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;
-}
-
-#endif /* ARM Neon Support.*/
-
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
-
-#ifdef HAVE_X86INTRIN_H
-#include <x86intrin.h>
-
-#define HAVE_SIMD 1
-#define HAVE_SIMD_SSE2 1
-
-#ifdef HAVE_CPUID_H
-#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
-
-#include <cpuid.h>
-#endif /* HAVE_CPUID_H */
-
-static SIMD_Implementation find_simd_implementation(void) {
-
-#if defined(__GNUC__ ) || defined(__clang__)
-#ifdef __GNUC__ 
-    __builtin_cpu_init();
-#endif /* __GNUC__  */
-
-    // TODO Revisit. I think the SSE version now only uses SSE2 instructions.
-    if (__builtin_cpu_supports("sse2")) {
-        return SIMD_SSE2;
-    }
-#endif /* __GNUC__ || __clang__*/
-
-    return SIMD_NONE;
-}
-
-#endif /* HAVE_X86INTRIN_H */
-#endif /* X86_64 Support */
-
-#endif /* JSON_ENABLE_SIMD */
-
-#ifndef FIND_SIMD_IMPLEMENTATION_DEFINED
-static SIMD_Implementation find_simd_implementation(void) {
-    return SIMD_NONE;
-}
-#endif