oj 3.13.14 → 3.13.22

data/ext/oj/dump_object.c

@@ -315,7 +315,6 @@ static void dump_hash_class(VALUE obj, VALUE clas, int depth, Out out) {
     *out->cur = '\0';
 }
 
-#ifdef HAVE_RB_IVAR_FOREACH
 static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     Out         out   = (Out)ov;
     int         depth = out->depth;
@@ -358,7 +357,6 @@ static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
 
     return ST_CONTINUE;
 }
-#endif
 
 static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
     dump_hash_class(obj, rb_obj_class(obj), depth, out);
@@ -510,19 +508,8 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
     default: break;
     }
     {
-        int cnt;
-#ifdef HAVE_RB_IVAR_COUNT
-        cnt = (int)rb_ivar_count(obj);
-#else
-        volatile VALUE vars = rb_funcall2(obj, oj_instance_variables_id, 0, 0);
-        VALUE *        np   = RARRAY_PTR(vars);
-        ID             vid;
-        const char *   attr;
-        int            i;
-        int            first = 1;
-
-        cnt  = (int)RARRAY_LEN(vars);
-#endif
+        int cnt = (int)rb_ivar_count(obj);
+
         if (Qundef != clas && 0 < cnt) {
             *out->cur++ = ',';
         }
@@ -535,52 +522,10 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
             }
         }
         out->depth = depth + 1;
-#ifdef HAVE_RB_IVAR_FOREACH
         rb_ivar_foreach(obj, dump_attr_cb, (VALUE)out);
         if (',' == *(out->cur - 1)) {
             out->cur--;  // backup to overwrite last comma
         }
-#else
-        size = d2 * out->indent + 1;
-        for (i = cnt; 0 < i; i--, np++) {
-            VALUE value;
-
-            vid  = rb_to_id(*np);
-            attr = rb_id2name(vid);
-            if (Yes == out->opts->ignore_under && '@' == *attr && '_' == attr[1]) {
-                continue;
-            }
-            value = rb_ivar_get(obj, vid);
-
-            if (dump_ignore(out->opts, value)) {
-                continue;
-            }
-            if (out->omit_nil && Qnil == value) {
-                continue;
-            }
-            if (first) {
-                first = 0;
-            } else {
-                *out->cur++ = ',';
-            }
-            assure_size(out, size);
-            fill_indent(out, d2);
-            if ('@' == *attr) {
-                attr++;
-                oj_dump_cstr(attr, strlen(attr), 0, 0, out);
-            } else {
-                char buf[32];
-
-                *buf = '~';
-                strncpy(buf + 1, attr, sizeof(buf) - 2);
-                buf[sizeof(buf) - 1] = '\0';
-                oj_dump_cstr(buf, strlen(attr) + 1, 0, 0, out);
-            }
-            *out->cur++ = ':';
-            oj_dump_obj_val(value, d2, out);
-            assure_size(out, 2);
-        }
-#endif
         if (rb_obj_is_kind_of(obj, rb_eException)) {
             volatile VALUE rv;
 
@@ -737,7 +682,7 @@ static DumpFunc obj_funcs[] = {
 void oj_dump_obj_val(VALUE obj, int depth, Out out) {
     int type = rb_type(obj);
 
-    if (Yes == out->opts->trace) {
+    if (RB_UNLIKELY(Yes == out->opts->trace)) {
         oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
     }
     if (MAX_DEPTH < depth) {
@@ -748,14 +693,14 @@ void oj_dump_obj_val(VALUE obj, int depth, Out out) {
 
         if (NULL != f) {
             f(obj, depth, out, false);
-            if (Yes == out->opts->trace) {
+            if (RB_UNLIKELY(Yes == out->opts->trace)) {
                 oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
             }
             return;
         }
     }
     oj_dump_nil(Qnil, depth, out, false);
-    if (Yes == out->opts->trace) {
+    if (RB_UNLIKELY(Yes == out->opts->trace)) {
         oj_trace("dump", Qnil, __FILE__, __LINE__, depth, TraceOut);
     }
 }

data/ext/oj/dump_strict.c

@@ -338,7 +338,7 @@ static DumpFunc strict_funcs[] = {
 void oj_dump_strict_val(VALUE obj, int depth, Out out) {
     int type = rb_type(obj);
 
-    if (Yes == out->opts->trace) {
+    if (RB_UNLIKELY(Yes == out->opts->trace)) {
         oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
     }
     if (MAX_DEPTH < depth) {
@@ -349,7 +349,7 @@ void oj_dump_strict_val(VALUE obj, int depth, Out out) {
 
         if (NULL != f) {
             f(obj, depth, out, false);
-            if (Yes == out->opts->trace) {
+            if (RB_UNLIKELY(Yes == out->opts->trace)) {
                 oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
             }
             return;
@@ -386,7 +386,7 @@ static DumpFunc null_funcs[] = {
 void oj_dump_null_val(VALUE obj, int depth, Out out) {
     int type = rb_type(obj);
 
-    if (Yes == out->opts->trace) {
+    if (RB_UNLIKELY(Yes == out->opts->trace)) {
         oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
     }
     if (MAX_DEPTH < depth) {
@@ -397,14 +397,14 @@ void oj_dump_null_val(VALUE obj, int depth, Out out) {
 
         if (NULL != f) {
             f(obj, depth, out, false);
-            if (Yes == out->opts->trace) {
+            if (RB_UNLIKELY(Yes == out->opts->trace)) {
                 oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
             }
             return;
         }
     }
     oj_dump_nil(Qnil, depth, out, false);
-    if (Yes == out->opts->trace) {
+    if (RB_UNLIKELY(Yes == out->opts->trace)) {
         oj_trace("dump", Qnil, __FILE__, __LINE__, depth, TraceOut);
     }
 }

data/ext/oj/extconf.rb

@@ -23,14 +23,10 @@ dflags = {
   'RSTRUCT_LEN_RETURNS_INTEGER_OBJECT' => ('ruby' == type && '2' == version[0] && '4' == version[1] && '1' >= version[2]) ? 1 : 0,
 }
 
-have_func('rb_time_timespec')
-have_func('rb_ivar_count')
-have_func('rb_ivar_foreach')
 # Support for compaction.
 have_func('rb_gc_mark_movable')
 have_func('stpcpy')
 have_func('pthread_mutex_init')
-have_func('rb_enc_associate')
 have_func('rb_enc_interned_str')
 have_func('rb_ext_ractor_safe', 'ruby.h')
 # rb_hash_bulk_insert is deep down in a header not included in normal build and that seems to fool have_func.
@@ -38,6 +34,11 @@ have_func('rb_hash_bulk_insert', 'ruby.h') unless '2' == version[0] && '6' == ve
 
 dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
 
+if with_config('--with-sse42')
+  $CPPFLAGS += ' -msse4.2'
+  dflags['OJ_USE_SSE4_2'] = 1
+end
+
 dflags.each do |k,v|
   if v.nil?
     $CPPFLAGS += " -D#{k}"

data/ext/oj/fast.c

@@ -677,21 +677,23 @@ static void free_doc_cb(void *x) {
 }
 
 static void mark_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                mark_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: mark(leaf->value); break;
+                do {
+                    mark_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: mark(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 

data/ext/oj/intern.c

@@ -37,13 +37,10 @@ typedef struct _hash {
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static struct _cache *str_cache = NULL;
 static VALUE          str_cache_obj;
 
-static struct _cache *sym_cache = NULL;
 static VALUE          sym_cache_obj;
 
-static struct _cache *attr_cache = NULL;
 static VALUE          attr_cache_obj;
 
 static VALUE form_str(const char *str, size_t len) {
@@ -93,15 +90,15 @@ void oj_hash_init(void) {
     rb_gc_register_address(&cache_class);
     rb_undef_alloc_func(cache_class);
 
-    str_cache     = cache_create(0, form_str, true, true);
+    struct _cache *str_cache     = cache_create(0, form_str, true, true);
     str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    sym_cache     = cache_create(0, form_sym, true, true);
+    struct _cache *sym_cache     = cache_create(0, form_sym, true, true);
     sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
-    attr_cache     = cache_create(0, form_attr, false, true);
+    struct _cache *attr_cache = cache_create(0, form_attr, false, true);
     attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
@@ -122,18 +119,18 @@ oj_str_intern(const char *key, size_t len) {
 #if HAVE_RB_ENC_INTERNED_STR && 0
     return rb_enc_interned_str(key, len, rb_utf8_encoding());
 #else
-    return cache_intern(str_cache, key, len);
+    return cache_intern(DATA_PTR(str_cache_obj), key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-    return cache_intern(sym_cache, key, len);
+  return cache_intern(DATA_PTR(sym_cache_obj), key, len);
 }
 
 ID
 oj_attr_intern(const char *key, size_t len) {
-    return cache_intern(attr_cache, key, len);
+  return cache_intern(DATA_PTR(attr_cache_obj), key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {

data/ext/oj/introspect.c

@@ -0,0 +1,96 @@
+
+#include "cache.h"
+#include "oj.h"
+#include "parser.h"
+#include "usual.h"
+
+#define BYTE_OFFSETS_STACK_INC_SIZE 256
+
+VALUE mod = Qnil;
+
+typedef struct _introspect {
+    struct _usual usual;
+    void (*start)(struct _ojParser *p);
+    void (*free)(struct _ojParser *p);
+    void (*mark)(struct _ojParser *p);
+    void (*open_object)(struct _ojParser *p);
+    void (*close_object)(struct _ojParser *p);
+
+    int len;
+    int cur;
+    long *stack;
+
+} * Introspect;
+
+static void dfree(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    xfree(d->stack);
+    // As with the mark() function, this function should still work.
+    d->free(p);
+}
+
+static void start(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->start(p);
+
+    d->stack = ALLOC_N(long, BYTE_OFFSETS_STACK_INC_SIZE);
+    d->len = BYTE_OFFSETS_STACK_INC_SIZE;
+    d->cur = 0;
+}
+
+static void open_object(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->open_object(p);
+
+    // TBD add offset
+}
+
+static void close_object(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->close_object(p);
+
+    // TBD set offset on hash
+}
+
+static VALUE new_parser(VALUE self, VALUE ropts) {
+    volatile VALUE pv = oj_parser_new();
+    ojParser       p  = (ojParser)DATA_PTR(pv);
+    Introspect     d  = ALLOC(struct _introspect);
+
+    oj_init_usual(p, &d->usual);
+
+    // Set the options before switching to the Introspect delegate.
+    p->ctx    = (void *)d;
+
+    d->free = p->free;
+    p->free   = dfree;
+
+    d->start = p->start;
+    p->start  = start;
+
+    // We are cheating with the mark, free, and options functions. Since
+    // struct _usual is the first member of struct _introspect the cast to
+    // Usual in the usual.c mark() function should still work just fine.
+
+    d->open_object = p->funcs[TOP_FUN].open_object;
+    p->funcs[TOP_FUN].open_object = open_object;
+
+    d->close_object = p->funcs[TOP_FUN].close_object;
+    p->funcs[TOP_FUN].close_object = close_object;
+
+    Check_Type(ropts, T_HASH);
+    oj_parser_set_option(p, ropts);
+
+    return pv;
+}
+
+void Init_introspect(void) {
+    mod = rb_define_module("Introspect");
+    rb_gc_register_address(&mod);
+
+    rb_define_module_function(mod, "parser", new_parser, 1);
+}

data/ext/oj/mimic_json.c

@@ -388,6 +388,10 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
         VALUE active_hack[1];
 
         if (Qundef == state_class) {
+            rb_warn(
+              "Oj::Rails.mimic_JSON was called implicitly. "
+              "Call it explicitly beforehand if you want to remove this warning."
+            );
             oj_define_mimic_json(0, NULL, Qnil);
         }
         active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
@@ -481,6 +485,10 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
         rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
     }
     if (Qundef == state_class) {
+        rb_warn(
+          "Oj::Rails.mimic_JSON was called implicitly. "
+          "Call it explicitly beforehand if you want to remove this warning."
+        );
         oj_define_mimic_json(0, NULL, Qnil);
     }
     rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);
@@ -536,14 +544,6 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE info) {
         }
     } else if (oj_decimal_class_sym == k) {
         pi->options.compat_bigdec = (oj_bigdecimal_class == v);
-    } else if (oj_max_nesting_sym == k) {
-        if (Qtrue == v) {
-            pi->max_depth = 100;
-        } else if (Qfalse == v || Qnil == v) {
-            pi->max_depth = 0;
-        } else if (T_FIXNUM == rb_type(v)) {
-            pi->max_depth = NUM2INT(v);
-        }
     }
     return ST_CONTINUE;
 }
@@ -573,11 +573,21 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
     pi.max_depth             = 100;
 
     if (Qnil != ropts) {
+        VALUE v;
+
         if (T_HASH != rb_type(ropts)) {
             rb_raise(rb_eArgError, "options must be a hash.");
         }
 
         rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
+        v = rb_hash_lookup(ropts, oj_max_nesting_sym);
+        if (Qtrue == v) {
+            pi.max_depth = 100;
+        } else if (Qfalse == v || Qnil == v) {
+            pi.max_depth = 0;
+        } else if (T_FIXNUM == rb_type(v)) {
+            pi.max_depth = NUM2INT(v);
+        }
         oj_parse_opt_match_string(&pi.options.str_rx, ropts);
         if (Yes == pi.options.create_ok && Yes == pi.options.sym_key) {
             rb_raise(rb_eArgError, ":symbolize_names and :create_additions can not both be true.");

data/ext/oj/object.c

@@ -67,9 +67,9 @@ static VALUE str_to_value(ParseInfo pi, const char *str, size_t len, const char
 
 // The much faster approach (4x faster)
 static int parse_num(const char *str, const char *end, int cnt) {
-    int n = 0;
+    int  n = 0;
     char c;
-    int i;
+    int  i;
 
     for (i = cnt; 0 < i; i--, str++) {
         c = *str;
@@ -83,9 +83,9 @@ static int parse_num(const char *str, const char *end, int cnt) {
 
 VALUE
 oj_parse_xml_time(const char *str, int len) {
-    VALUE args[8];
+    VALUE       args[8];
     const char *end = str + len;
-    int n;
+    int         n;
 
     // year
     if (0 > (n = parse_num(str, end, 4))) {
@@ -269,19 +269,10 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
                     // match the expected value.
                     parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
                 } else if (ni->has_exp) {
-                    int64_t          t = (int64_t)(ni->i + ni->exp);
-                    struct _timeInfo ti;
-                    VALUE            args[8];
-
-                    sec_as_time(t, &ti);
-                    args[0]     = LONG2NUM((long)(ti.year));
-                    args[1]     = LONG2NUM(ti.mon);
-                    args[2]     = LONG2NUM(ti.day);
-                    args[3]     = LONG2NUM(ti.hour);
-                    args[4]     = LONG2NUM(ti.min);
-                    args[5]     = rb_float_new((double)ti.sec + ((double)nsec + 0.5) / 1000000000.0);
-                    args[6]     = LONG2NUM(ni->exp);
-                    parent->val = rb_funcall2(rb_cTime, oj_new_id, 7, args);
+                    struct timespec ts;
+                    ts.tv_sec = ni->i;
+                    ts.tv_nsec = nsec;
+                    parent->val = rb_time_timespec_new(&ts, (int)ni->exp);
                 } else {
                     parent->val = rb_time_nano_new(ni->i, (long)nsec);
                 }
@@ -333,26 +324,30 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 // If struct is not defined then we let this fail and raise an exception.
                 sc = oj_name2struct(pi, *RARRAY_PTR(value), rb_eArgError);
             }
-            // Create a properly initialized struct instance without calling the initialize method.
-            parent->val = rb_obj_alloc(sc);
-            // If the JSON array has more entries than the struct class allows, we record an error.
+            if (sc == rb_cRange) {
+              parent->val = rb_class_new_instance(len - 1, RARRAY_PTR(value) + 1, rb_cRange);
+            } else {
+                // Create a properly initialized struct instance without calling the initialize method.
+                parent->val = rb_obj_alloc(sc);
+                // If the JSON array has more entries than the struct class allows, we record an error.
 #ifdef RSTRUCT_LEN
 #if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
             slen = (int)NUM2LONG(RSTRUCT_LEN(parent->val));
 #else   // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
-            slen = (int)RSTRUCT_LEN(parent->val);
+                slen = (int)RSTRUCT_LEN(parent->val);
 #endif  // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
 #else
-            slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
+                slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
 #endif
-            // MRI >= 1.9
-            if (len - 1 > slen) {
-                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
-            } else {
-                int i;
+                // MRI >= 1.9
+                if (len - 1 > slen) {
+                    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+                } else {
+                    int i;
 
-                for (i = 0; i < len - 1; i++) {
-                    rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+                    for (i = 0; i < len - 1; i++) {
+                        rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+                    }
                 }
             }
             return 1;
@@ -374,11 +369,17 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
 }
 
 void oj_set_obj_ivar(Val parent, Val kval, VALUE value) {
-    rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    if (kval->klen == 5 && strncmp("~mesg", kval->key, 5) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        parent->val = rb_funcall(parent->val, rb_intern("exception"), 1, value);
+    } else if (kval->klen == 3 && strncmp("~bt", kval->key, 3) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        rb_funcall(parent->val, rb_intern("set_backtrace"), 1, value);
+    } else {
+        rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    }
 }
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;
@@ -445,13 +446,13 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rval);
     }
 }
 
 static void hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;
@@ -516,7 +517,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, rval);
     }
 }
@@ -602,13 +603,13 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, value);
     }
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
     }
     return Qnil;
@@ -626,7 +627,7 @@ static void end_hash(ParseInfo pi) {
         oj_odd_free(oa);
         parent->odd_args = NULL;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
     }
 }
@@ -654,7 +655,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     }
     rval = str_to_value(pi, str, len, orig);
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rval);
     }
 }
@@ -663,21 +664,21 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
     }
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     pi->stack.head->val = str_to_value(pi, str, len, orig);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
     pi->stack.head->val = oj_num_as_value(ni);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_num", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }