oj 3.17.6 → 3.17.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af3a1f2b343eefacdaeb1f82d4b48fe67bece49e4aae63ad46aa878f726ae3de
-  data.tar.gz: 8cd6e1ac300706f39d434cbbba52ea780a96b761ba2090d3d3624185bc021819
+  metadata.gz: 6d8e7bd60ca653140f1d101a88ded37ad5b6fe2af3d5e01ae6787435238c75eb
+  data.tar.gz: 9ef057d4e77c5b2ba30f9a34b2fc3621875c902ca05da25495a4abf657f0bbdb
 SHA512:
-  metadata.gz: e081fafa7bd5af792fef91dc58612d6ea85bdae7b3d709bbd945773a5ad9d1feec4c88e3844aa403098c3fa267814ef61dcbba5fb4d9ee86a239eecf5b3926fa
-  data.tar.gz: 339ba6bedb36fb30a382f8cb5037053a4197d4e9364bb11f50b79ec6ec3002cdd687868e140fec1dacabdc9cfa972a45cfcd6cb8a85e4c4148cd484f56278004
+  metadata.gz: b9654f35d338c316388534ee7d7143165dd2aab82960324f7fd313771445a2dc2d2b22964408b533735dab30e4fd554b5f8abe272a7b3beb5352720cd039fb16
+  data.tar.gz: 4ffc5a78fc866f6824564d34e2db316c56454999bdcb0f91068b40e4dd28f04f23acfb9ce819364bb6a33c3aa5c2e3be0979982220552a1ec3a5eceedfd6f320

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 3.17.7 - 2026-09-29
+
+### Fixed
+ - issue #1104, where `Oj.dump` in compat and custom mode forwarded its whole options hash to the `to_json` methods it calls, so with json 3.0, whose generator raises `ArgumentError` on options it does not know, dumping a `Time` or any other object whose `to_json` comes from the json gem failed with `unknown keywords: mode, use_to_json`. Nested values reach `to_json` even without `use_to_json`, so `Oj.dump(data, mode: :compat)` failed the same way for data holding a `BigDecimal` or `Time`. The options Oj acts on are now dropped from the hash `to_json` receives, except `:only` and `:except`, which ActiveSupport's `as_json` reads. Keys Oj does not know are passed through untouched.
+ - Speed up hash-heavy documents: skip the 11KB per-parse memset and bulk-insert hashes (#1096)
+ - Preserve decimal placement for large parser numbers (#1099)
+ - Keep zero digits in oversized parser exponents (#1100)
+ - Parse very small usual-mode numbers correctly (#1101)
+ - Speed up symbol keys by interning without a temporary String (#1102)
+ - Keep Oj's own options out of the hash passed to to_json (#1106)
+ - Ensure class-cache mutex is released on exceptions (#1108)
+ - Guard __has_include with an #ifdef to support older GCC versions (4.4.7 etc.) (#1111)
+
 ## 3.17.6 - 2026-08-10
 
 - Fixed issue #1092, where the encoder ActiveSupport 8.1 caches with `escape: false` froze the options as they stood before `set_encoder` wrote `time_precision` into them, so `to_json(escape: false)` emitted 9 fractional digits. An options hash that names no option Oj knows no longer detaches an encoder from the defaults. (#1093)

data/ext/oj/compat.c

@@ -33,7 +33,10 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
             }
         }
-        if (rb_cHash != rb_obj_class(parent->val)) {
+        if (Qnil == pi->options.hash_class) {
+            stack_pair_push(&pi->stack, rkey, rstr);
+            parent->pcnt += 2;
+        } else if (rb_cHash != rb_obj_class(parent->val)) {
             // The rb_hash_set would still work but the unit tests for the
             // json gem require the less efficient []= method be called to set
             // values. Even using the store method to set the values will fail
@@ -47,20 +50,34 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    volatile VALUE h;
-
     if (Qnil != pi->options.hash_class) {
-        h = rb_class_new_instance(0, NULL, pi->options.hash_class);
-    } else {
-        h = rb_hash_new();
+        return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
-    return h;
+    // The Hash is built at end_hash from the buffered pairs.
+    return Qundef;
 }
 
 static void end_hash(struct _parseInfo *pi) {
     Val parent = stack_peek(&pi->stack);
 
+    if (Qnil == pi->options.hash_class) {
+        ValStack       stack = &pi->stack;
+        size_t         cnt   = parent->pcnt;
+        volatile VALUE h;
+
+#if HAVE_RB_HASH_NEW_CAPA
+        h = rb_hash_new_capa((long)(cnt / 2));
+#else
+        h = rb_hash_new();
+#endif
+        if (0 < cnt) {
+            rb_hash_bulk_insert((long)cnt, stack->pairs + stack->pcnt - cnt, h);
+            stack->pcnt -= cnt;
+            parent->pcnt = 0;
+        }
+        parent->val = h;
+    }
     if (0 != parent->classname) {
         volatile VALUE clas;
 
@@ -103,7 +120,10 @@ static void add_num(ParseInfo pi, NumInfo ni) {
 static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
-    if (rb_cHash != rb_obj_class(parent->val)) {
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), rval);
+        parent->pcnt += 2;
+    } else if (rb_cHash != rb_obj_class(parent->val)) {
         // The rb_hash_set would still work but the unit tests for the
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail
@@ -116,7 +136,10 @@ static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    if (rb_cHash != rb_obj_class(parent->val)) {
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), value);
+        parent->pcnt += 2;
+    } else if (rb_cHash != rb_obj_class(parent->val)) {
         // The rb_hash_set would still work but the unit tests for the
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail

data/ext/oj/custom.c

@@ -1033,8 +1033,24 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
+// Compat mode defers Hash creation to its end_hash (bulk insert from the
+// buffered pairs) but the custom callbacks below fill the Hash as they go,
+// so hashes must exist from the opening brace here.
+static VALUE start_hash(ParseInfo pi) {
+    volatile VALUE h;
+
+    if (Qnil != pi->options.hash_class) {
+        h = rb_class_new_instance(0, NULL, pi->options.hash_class);
+    } else {
+        h = rb_hash_new();
+    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
+    return h;
+}
+
 void oj_set_custom_callbacks(ParseInfo pi) {
     oj_set_compat_callbacks(pi);
+    pi->start_hash        = start_hash;
     pi->hash_set_cstr     = hash_set_cstr;
     pi->end_hash          = end_hash;
     pi->hash_set_num      = hash_set_num;

data/ext/oj/extconf.rb

@@ -31,6 +31,7 @@ have_func('stpcpy')
 have_func('pthread_mutex_init')
 have_func('getrlimit', 'sys/resource.h')
 have_func('rb_enc_interned_str')
+have_func('rb_hash_new_capa', 'ruby.h')
 have_func('rb_ext_ractor_safe', 'ruby.h')
 have_func('rb_hash_start', 'ruby.h')
 
@@ -48,6 +49,12 @@ if try_cflags('-msse2')
   $CPPFLAGS += ' -msse2'
 end
 
+# Ensure C99 mode for compilers that default to C90 (e.g. GCC 4.x).
+# simd.h uses C99 for-loop declarations that fail under -std=gnu90.
+if !$CFLAGS.include?('-std=') && try_cflags('-std=gnu99')
+  $CFLAGS += ' -std=gnu99'
+end
+
 if enable_config('trace-log', false)
   dflags['OJ_ENABLE_TRACE_LOG'] = 1
 end

data/ext/oj/intern.c

@@ -50,7 +50,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_to_symbol(rb_str_intern(rb_utf8_str_new(str, len)));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -243,61 +248,83 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     return clas;
 }
 
+typedef struct _internArgs {
+    KeyVal      bucket;  // last bucket in the chain for the key's slot
+    const char *key;
+    size_t      len;
+    ParseInfo   pi;
+    int         auto_define;
+    VALUE       error_class;
+} *InternArgs;
+
+// Resolves the class and only then adds it to the cache so a raise while
+// resolving does not leave a key cached with no value.
+static VALUE intern_new_class(VALUE a) {
+    InternArgs args   = (InternArgs)a;
+    KeyVal     bucket = args->bucket;
+    VALUE      clas   = resolve_classpath(args->pi, args->key, args->len, args->auto_define, args->error_class);
+
+    if (NULL != bucket->key) {  // not the top slot
+        KeyVal b = OJ_R_ALLOC(struct _keyVal);
+
+        b->next      = NULL;
+        bucket->next = b;
+        bucket       = b;
+    }
+    bucket->key = oj_strndup(args->key, args->len);
+    bucket->len = args->len;
+    bucket->val = clas;
+
+    return clas;
+}
+
+static KeyVal find_class(KeyVal bucket, const char *key, size_t len, VALUE *clas) {
+    if (NULL != bucket->key) {  // not the top slot
+        for (KeyVal b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+                *clas = b->val;
+                return NULL;
+            }
+            bucket = b;
+        }
+    }
+    return bucket;
+}
+
 VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int auto_define, VALUE error_class) {
-    uint64_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
-    KeyVal   bucket = class_hash.slots + h;
-    KeyVal   b;
+    uint64_t           h    = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    struct _internArgs args = {NULL, key, len, pi, auto_define, error_class};
+    VALUE              clas = Qundef;
 
     if (safe) {
+        int state = 0;
+
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&class_hash.mutex);
 #else
         rb_mutex_lock(class_hash.mutex);
 #endif
-        if (NULL != bucket->key) {  // not the top slot
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-#if HAVE_PTHREAD_MUTEX_INIT
-                    pthread_mutex_unlock(&class_hash.mutex);
-#else
-                    rb_mutex_unlock(class_hash.mutex);
-#endif
-                    return b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        // Resolving calls into Ruby and allocating, either of which can
+        // raise and unwind past the unlock, so the work is protected and any
+        // exception rethrown after the mutex is released.
+        if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+            clas = rb_protect(intern_new_class, (VALUE)&args, &state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_unlock(&class_hash.mutex);
 #else
         rb_mutex_unlock(class_hash.mutex);
 #endif
-    } else {
-        if (NULL != bucket->key) {
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-                    return (ID)b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        if (0 != state) {
+            rb_jump_tag(state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
+    } else if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+        clas = intern_new_class((VALUE)&args);
     }
-    rb_gc_register_mark_object(bucket->val);
-    return bucket->val;
+    if (NULL != args.bucket) {  // newly added to the cache
+        rb_gc_register_mark_object(clas);
+    }
+    return clas;
 }
 
 char *oj_strndup(const char *s, size_t len) {

data/ext/oj/mimic_json.c

@@ -461,7 +461,7 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
     } else {
-        h = argv[1];
+        h = rb_hash_dup(argv[1]);
     }
     if (!oj_hash_has_key(h, oj_indent_sym)) {
         rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));

data/ext/oj/oj.c

@@ -1241,45 +1241,84 @@ static bool parse_one_option(VALUE k, VALUE v, Options copts) {
     return true;
 }
 
-// Collects the return of parse_one_option() over every key in a hash.
+// Collects the results of parse_one_option() over every key in a hash.
 struct _optsParse {
     Options copts;
-    bool    consumed;
+    bool    consumed;  // some key was an Oj option
+    VALUE   orig;      // the caller's hash, never modified
+    VALUE   rest;      // orig, or a copy of it without the Oj options
 };
 
+static void drop_from_rest(struct _optsParse *op, VALUE k) {
+    if (op->rest == op->orig) {
+        op->rest = rb_hash_dup(op->orig);
+    }
+    rb_hash_delete(op->rest, k);
+}
+
 static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
     struct _optsParse *op = (struct _optsParse *)opts;
 
     if (parse_one_option(k, v, op->copts)) {
         op->consumed = true;
+        // :only and :except are also read by ActiveSupport's as_json, which
+        // compat mode reaches through to_json, so they are left in.
+        if (only_sym != k && except_sym != k) {
+            drop_from_rest(op, k);
+        }
     }
     return ST_CONTINUE;
 }
 
-// Apply the options in ropts to copts and report whether any key was
-// recognized. A hash of nothing but unknown keys leaves copts untouched and
-// returns false.
-bool oj_parse_options_consumed(VALUE ropts, Options copts) {
-    struct _optsParse op = {copts, false};
+static void parse_options(VALUE ropts, Options copts, struct _optsParse *op) {
+    op->copts    = copts;
+    op->consumed = false;
+    op->orig     = ropts;
+    op->rest     = ropts;
 
     if (T_HASH != rb_type(ropts)) {
-        return false;
+        return;
     }
-    rb_hash_foreach(ropts, parse_options_cb, (VALUE)&op);
+    rb_hash_foreach(ropts, parse_options_cb, (VALUE)op);
     if (Qnil != rb_hash_lookup(ropts, match_string_sym)) {
-        op.consumed = true;
+        op->consumed = true;
+        drop_from_rest(op, match_string_sym);
     }
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size || 0 < copts->dump_opts.after_size ||
                             0 < copts->dump_opts.before_size || 0 < copts->dump_opts.hash_size ||
                             0 < copts->dump_opts.array_size);
+}
+
+// Apply the options in ropts to copts and report whether any key was
+// recognized. A hash of nothing but unknown keys leaves copts untouched and
+// returns false.
+bool oj_parse_options_consumed(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
 
     return op.consumed;
 }
 
+// Apply the options in ropts to copts and return what is left for the
+// to_json and as_json methods that Oj.dump() calls: ropts itself when it
+// holds no Oj option, otherwise a copy without them. The json gem's
+// generator raises on options it does not know as of json 3.0, so Oj's own
+// must not reach it. ropts is never modified.
+VALUE oj_parse_options_rest(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
+
+    return op.rest;
+}
+
 void oj_parse_options(VALUE ropts, Options copts) {
-    oj_parse_options_consumed(ropts, copts);
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
 }
 
 // Free the option buffers that oj_parse_options() allocated for a single call.
@@ -1703,6 +1742,7 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
     struct dump_arg arg;
     struct _out     out;
     struct _options copts = oj_default_options;
+    VALUE           to_json_argv[2];
 
     if (1 > argc) {
         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
@@ -1711,7 +1751,11 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
         copts.dump_opts.nan_dump = WordNan;
     }
     if (2 == argc) {
-        oj_parse_options(argv[1], &copts);
+        // The options hash is also what to_json and as_json receive, so
+        // hand them the hash without the options Oj itself acted on.
+        to_json_argv[0] = argv[0];
+        to_json_argv[1] = oj_parse_options_rest(argv[1], &copts);
+        argv            = to_json_argv;
     }
     if (CompatMode == copts.mode && copts.escape_mode != ASCIIEsc) {
         copts.escape_mode = JSONEsc;

data/ext/oj/oj.h

@@ -255,13 +255,14 @@ extern VALUE oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 extern VALUE oj_object_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
 extern VALUE oj_custom_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
 
-extern bool oj_hash_has_key(VALUE hash, VALUE key);
-extern void oj_parse_options(VALUE ropts, Options copts);
-extern bool oj_parse_options_consumed(VALUE ropts, Options copts);
-extern void oj_free_call_options(Options copts);
-extern void oj_options_take_ownership(Options copts);
-extern void oj_options_release(Options copts);
-extern void oj_options_mark(Options copts);
+extern bool  oj_hash_has_key(VALUE hash, VALUE key);
+extern void  oj_parse_options(VALUE ropts, Options copts);
+extern bool  oj_parse_options_consumed(VALUE ropts, Options copts);
+extern VALUE oj_parse_options_rest(VALUE ropts, Options copts);
+extern void  oj_free_call_options(Options copts);
+extern void  oj_options_take_ownership(Options copts);
+extern void  oj_options_release(Options copts);
+extern void  oj_options_mark(Options copts);
 
 extern void  oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
 extern void  oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);

data/ext/oj/parse.c

@@ -1261,7 +1261,11 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
     // value stack (while it is in scope).
     wrapped_stack = oj_stack_init(&pi->stack);
     rb_protect(protect_parse, (VALUE)pi, &line);
-    if (Qundef == pi->stack.head->val && !empty_ok(&pi->options)) {
+    // Only when nothing is on the stack was the input actually empty. A
+    // deferred hash (built at its closing brace from buffered pairs) leaves
+    // head->val Qundef while its entry is still on the stack, e.g. when a
+    // parse error cut the document short; the real error is already set.
+    if (Qundef == pi->stack.head->val && stack_empty(&pi->stack) && !empty_ok(&pi->options)) {
         if (No == pi->options.nilnil || (CompatMode == pi->options.mode && 0 < pi->cur - pi->json)) {
             oj_set_error_at(pi, oj_json_parser_error_class, __FILE__, __LINE__, "Empty input");
         }

data/ext/oj/parse.h

@@ -5,6 +5,7 @@
 #define OJ_PARSE_H
 
 #include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -90,7 +91,19 @@ extern VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str);
 extern VALUE oj_calc_hash_key(ParseInfo pi, Val parent);
 
 static inline void parse_info_init(ParseInfo pi) {
-    memset(pi, 0, sizeof(struct _parseInfo));
+    // Zeroing the whole struct costs more than parsing a small document: the
+    // embedded reader buffer (rd.base, 4KB) and value stack entries
+    // (stack.base, 6.5KB) dominate its 11KB. Both are fully initialized
+    // before use — oj_reader_init() for stream parses, oj_stack_init() and
+    // stack_push() for the value stack — so zero only the scalars around
+    // them.
+    memset(pi, 0, offsetof(struct _parseInfo, rd));
+    memset((char *)pi + offsetof(struct _parseInfo, rd) + offsetof(struct _reader, head),
+           0,
+           offsetof(struct _parseInfo, stack) - offsetof(struct _parseInfo, rd) - offsetof(struct _reader, head));
+    memset((char *)pi + offsetof(struct _parseInfo, stack) + offsetof(struct _valStack, head),
+           0,
+           sizeof(struct _parseInfo) - offsetof(struct _parseInfo, stack) - offsetof(struct _valStack, head));
 }
 
 extern void oj_scanner_init(void);

data/ext/oj/parser.c

@@ -509,20 +509,29 @@ static void calc_num(ojParser p) {
             d = -d;
         }
         if (0 < p->num.shift) {
-            d /= pow_map[p->num.shift];
-        }
-        if (0 < p->num.exp) {
-            long double x;
+            uint32_t shift = p->num.shift;
 
-            if (MAX_POW < p->num.exp) {
-                x = powl(10.0L, (long double)p->num.exp);
-            } else {
-                x = pow_map[p->num.exp];
+            while (MAX_POW < shift) {
+                d /= pow_map[MAX_POW];
+                shift -= MAX_POW;
             }
+            d /= pow_map[shift];
+        }
+        if (0 < p->num.exp) {
             if (p->num.exp_neg) {
-                d /= x;
+                int exp = p->num.exp;
+
+                while (MAX_POW < exp) {
+                    d /= pow_map[MAX_POW];
+                    exp -= MAX_POW;
+                }
+                d /= pow_map[exp];
             } else {
-                d *= x;
+                if (MAX_POW < p->num.exp) {
+                    d *= powl(10.0L, (long double)p->num.exp);
+                } else {
+                    d *= pow_map[p->num.exp];
+                }
             }
         }
         p->num.dub = d;
@@ -559,19 +568,31 @@ static void big_change(ojParser p) {
         break;
     case OJ_DECIMAL: {
         int shift = p->num.shift;
+        int end   = sizeof(buf) - 1;
 
-        for (len = sizeof(buf) - 1; 0 < i; len--, i /= 10, shift--) {
-            if (0 == shift) {
-                buf[len] = '.';
-                len--;
-            }
-            buf[len] = '0' + (i % 10);
-        }
+        len = end;
+        do {
+            buf[--len] = '0' + (i % 10);
+            i /= 10;
+        } while (0 < i);
         if (p->num.neg) {
-            buf[len] = '-';
-            len--;
+            buf_append(&p->buf, '-');
+        }
+        if (end - len <= shift) {
+            buf_append_string(&p->buf, "0.", 2);
+            for (int cnt = shift - (end - len); 0 < cnt; cnt--) {
+                buf_append(&p->buf, '0');
+            }
+            buf_append_string(&p->buf, buf + len, end - len);
+        } else {
+            int decimal = end - shift;
+
+            buf_append_string(&p->buf, buf + len, decimal - len);
+            if (0 < shift) {
+                buf_append(&p->buf, '.');
+                buf_append_string(&p->buf, buf + decimal, shift);
+            }
         }
-        buf_append_string(&p->buf, buf + len + 1, sizeof(buf) - len - 1);
         if (0 < p->num.exp) {
             int  x = p->num.exp;
             int  d, div;
@@ -585,6 +606,7 @@ static void big_change(ojParser p) {
                 d = x / div % 10;
                 if (started || 0 < d) {
                     buf_append(&p->buf, '0' + d);
+                    started = true;
                 }
             }
         }

data/ext/oj/parser.h

@@ -34,7 +34,7 @@ typedef struct _num {
     uint32_t    len;
     int16_t     div;  // 10^div
     int16_t     exp;
-    uint8_t     shift;  // shift of fixnum to get decimal
+    uint32_t    shift;  // shift of fixnum to get decimal
     bool        neg;
     bool        exp_neg;
     // for numbers as strings, reuse buf

data/ext/oj/simd.h

@@ -99,9 +99,11 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 // 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
+#ifdef __has_include
 #if __has_include(<cpuid.h>)
 #include <cpuid.h>
 #endif
+#endif
 #if defined(__SSE4_2__) || defined(__SSE2__)
 // If any SSE is enabled globally, x86intrin.h should be available
 #include <x86intrin.h>
@@ -109,6 +111,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #define HAVE_SIMD_SSE2 1
 #else
 // Try to include headers anyway for target attribute functions
+#ifdef __has_include
 #if __has_include(<x86intrin.h>)
 #include <x86intrin.h>
 #define HAVE_SIMD_SSE4_2 1
@@ -123,6 +126,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #endif
 #endif
 #endif
+#endif
 
 // Target attribute macros for function-level SIMD enabling
 #if defined(__clang__) || defined(__GNUC__)

data/ext/oj/strict.c

@@ -47,7 +47,29 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
     return rkey;
 }
 
+// With the default Hash class the pairs of the just closed hash sit on top
+// of the pair buffer; build the Hash in one bulk insert with the final size
+// known instead of one rb_hash_aset per pair (which converts the small
+// ar_table to an st_table mid-insertion for hashes above 8 entries).
 static void hash_end(ParseInfo pi) {
+    if (Qnil == pi->options.hash_class) {
+        ValStack       stack = &pi->stack;
+        Val            hash  = stack_peek(stack);
+        size_t         cnt   = hash->pcnt;
+        volatile VALUE h;
+
+#if HAVE_RB_HASH_NEW_CAPA
+        h = rb_hash_new_capa((long)(cnt / 2));
+#else
+        h = rb_hash_new();
+#endif
+        if (0 < cnt) {
+            rb_hash_bulk_insert((long)cnt, stack->pairs + stack->pcnt - cnt, h);
+            stack->pcnt -= cnt;
+            hash->pcnt = 0;
+        }
+        hash->val = h;
+    }
     TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
@@ -84,13 +106,19 @@ static VALUE start_hash(ParseInfo pi) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
-    return rb_hash_new();
+    // The Hash is built at hash_end from the buffered pairs.
+    return Qundef;
 }
 
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), rstr);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
 }
 
@@ -101,12 +129,22 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), v);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, v);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), value);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 

data/ext/oj/usual.c

@@ -49,7 +49,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_str_intern(rb_utf8_str_new(str, len));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -172,9 +177,9 @@ static VALUE str_key(ojParser p, Key kp) {
 
 static VALUE sym_key(ojParser p, Key kp) {
     if ((size_t)kp->len < sizeof(kp->buf)) {
-        return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->buf, kp->len)));
+        return form_sym(kp->buf, kp->len);
     }
-    return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->key, kp->len)));
+    return form_sym(kp->key, kp->len);
 }
 
 static ID get_attr_id(ojParser p, Key kp) {

data/ext/oj/val_stack.c

@@ -21,6 +21,13 @@ static void stack_mark(void *ptr) {
     rb_mutex_lock(stack->mutex);
     rb_gc_mark(stack->mutex);
 #endif
+    {
+        size_t i;
+
+        for (i = 0; i < stack->pcnt; i++) {
+            rb_gc_mark(stack->pairs[i]);
+        }
+    }
     for (v = stack->head; v < stack->tail; v++) {
         if (Qnil != v->val && Qundef != v->val) {
             rb_gc_mark(v->val);
@@ -71,6 +78,9 @@ oj_stack_init(ValStack stack) {
     stack->head            = stack->base;
     stack->end             = stack->base + sizeof(stack->base) / sizeof(struct _val);
     stack->tail            = stack->head;
+    stack->pairs           = stack->pbase;
+    stack->pcnt            = 0;
+    stack->pend            = sizeof(stack->pbase) / sizeof(VALUE);
     stack->head->val       = Qundef;
     stack->head->key       = NULL;
     stack->head->key_val   = Qundef;
@@ -79,6 +89,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clas      = Qundef;
     stack->head->klen      = 0;
     stack->head->clen      = 0;
+    stack->head->pcnt      = 0;
     stack->head->next      = NEXT_NONE;
 
     return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);

data/ext/oj/val_stack.h

@@ -37,16 +37,27 @@ typedef struct _val {
     OddArgs        odd_args;
     size_t         klen;
     size_t         clen;
+    size_t         pcnt;  // VALUEs this open hash holds in the stack pair buffer
     char           next;  // ValNext
     char           k1;    // first original character in the key
     char           kalloc;
 } *Val;
 
+#define PAIR_BASE_CNT 64
+
 typedef struct _valStack {
     struct _val base[STACK_INC];
-    Val         head;  // current stack
-    Val         end;   // stack end
-    Val         tail;  // pointer to one past last element name on stack
+    VALUE       pbase[PAIR_BASE_CNT];  // initial buffer for pairs
+    // Flat key/value pair buffer for hash modes that build each Hash in one
+    // rb_hash_bulk_insert at the closing brace instead of one rb_hash_aset
+    // per pair. Nesting is strictly LIFO so each open hash's pairs occupy
+    // the top of the buffer; the per-hash count lives in its Val's clen.
+    VALUE *pairs;
+    size_t pcnt;  // number of live VALUEs in pairs
+    size_t pend;  // capacity of pairs in VALUEs
+    Val    head;  // current stack
+    Val    end;   // stack end
+    Val    tail;  // pointer to one past last element name on stack
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_t mutex;
 #else
@@ -76,6 +87,11 @@ inline static void stack_cleanup(ValStack stack) {
         OJ_R_FREE(stack->head);
         stack->head = NULL;
     }
+    if (stack->pbase != stack->pairs) {
+        OJ_R_FREE(stack->pairs);
+        stack->pairs = NULL;
+    }
+    stack->pcnt = 0;
 }
 
 inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
@@ -124,6 +140,7 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
     stack->tail->key_val   = Qundef;
     stack->tail->clen      = 0;
     stack->tail->klen      = 0;
+    stack->tail->pcnt      = 0;
     stack->tail->kalloc    = 0;
     stack->tail++;
 }
@@ -165,6 +182,40 @@ inline static Val stack_pop(ValStack stack) {
     return 0;
 }
 
+// Append one key/value pair to the pair buffer. The same GC discipline as
+// stack_push: the allocation happens outside the mutex (it can trigger a GC
+// which takes the mutex in stack_mark) and the buffer pointer only changes
+// under the mutex.
+inline static void stack_pair_push(ValStack stack, VALUE key, VALUE value) {
+    if (stack->pend <= stack->pcnt + 2) {
+        size_t cnt = stack->pend * 2;
+        VALUE *pairs;
+
+        if (stack->pbase == stack->pairs) {
+            pairs = OJ_R_ALLOC_N(VALUE, cnt);
+            memcpy(pairs, stack->pairs, sizeof(VALUE) * stack->pcnt);
+        } else {
+            pairs = stack->pairs;
+            OJ_R_REALLOC_N(pairs, VALUE, cnt);
+        }
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_lock(&stack->mutex);
+#else
+        rb_mutex_lock(stack->mutex);
+#endif
+        stack->pairs = pairs;
+        stack->pend  = cnt;
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_unlock(&stack->mutex);
+#else
+        rb_mutex_unlock(stack->mutex);
+#endif
+    }
+    stack->pairs[stack->pcnt]     = key;
+    stack->pairs[stack->pcnt + 1] = value;
+    stack->pcnt += 2;
+}
+
 extern const char *oj_stack_next_string(ValNext n);
 
 #endif /* OJ_VAL_STACK_H */

data/lib/oj/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.17.6
+  version: 3.17.7
 platform: ruby
 authors:
 - Peter Ohler