oj 3.13.14 → 3.13.17

data/ext/oj/saj2.c

@@ -6,8 +6,8 @@
 
 typedef struct _delegate {
     VALUE          handler;
-    VALUE *        keys;
-    VALUE *        tail;
+    VALUE         *keys;
+    VALUE         *tail;
     size_t         klen;
     struct _cache *str_cache;
     uint8_t        cache_str;
@@ -17,7 +17,7 @@ typedef struct _delegate {
 
 static VALUE get_key(ojParser p) {
     Delegate       d   = (Delegate)p->ctx;
-    const char *   key = buf_str(&p->key);
+    const char    *key = buf_str(&p->key);
     size_t         len = buf_len(&p->key);
     volatile VALUE rkey;
 
@@ -48,6 +48,10 @@ static void open_object(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_hash_start_id, 1, Qnil);
 }
 
+static void open_object_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_hash_start_id, 3, Qnil, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void open_object_key(ojParser p) {
     Delegate       d   = (Delegate)p->ctx;
     volatile VALUE key = get_key(p);
@@ -56,10 +60,22 @@ static void open_object_key(ojParser p) {
     rb_funcall(d->handler, oj_hash_start_id, 1, key);
 }
 
+static void open_object_loc_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_hash_start_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void open_array(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_array_start_id, 1, Qnil);
 }
 
+static void open_array_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_array_start_id, 3, Qnil, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void open_array_key(ojParser p) {
     Delegate       d   = (Delegate)p->ctx;
     volatile VALUE key = get_key(p);
@@ -68,6 +84,14 @@ static void open_array_key(ojParser p) {
     rb_funcall(d->handler, oj_array_start_id, 1, key);
 }
 
+static void open_array_loc_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_array_start_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void close_object(ojParser p) {
     Delegate d   = (Delegate)p->ctx;
     VALUE    key = Qnil;
@@ -82,6 +106,20 @@ static void close_object(ojParser p) {
     rb_funcall(d->handler, oj_hash_end_id, 1, key);
 }
 
+static void close_object_loc(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_hash_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void close_array(ojParser p) {
     Delegate d   = (Delegate)p->ctx;
     VALUE    key = Qnil;
@@ -96,46 +134,160 @@ static void close_array(ojParser p) {
     rb_funcall(d->handler, oj_array_end_id, 1, key);
 }
 
+static void close_array_loc(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_array_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void add_null(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, Qnil);
 }
 
+static void add_null_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qnil,
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_null_key(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, get_key(p));
 }
 
+static void add_null_key_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qnil,
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_true(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, Qnil);
 }
 
+static void add_true_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qtrue,
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_true_key(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, get_key(p));
 }
 
+static void add_true_key_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qtrue,
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_false(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, Qnil);
 }
 
+static void add_false_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qfalse,
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_false_key(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, get_key(p));
 }
 
+static void add_false_key_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               Qfalse,
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_int(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), Qnil);
 }
 
+static void add_int_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               LONG2NUM(p->num.fixnum),
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_int_key(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), get_key(p));
 }
 
+static void add_int_key_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               LONG2NUM(p->num.fixnum),
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_float(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), Qnil);
 }
 
+static void add_float_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               rb_float_new(p->num.dub),
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_float_key(ojParser p) {
     rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), get_key(p));
 }
 
+static void add_float_key_loc(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler,
+               oj_add_value_id,
+               4,
+               rb_float_new(p->num.dub),
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_big(ojParser p) {
     rb_funcall((VALUE)p->ctx,
                oj_add_value_id,
@@ -144,6 +296,16 @@ static void add_big(ojParser p) {
                Qnil);
 }
 
+static void add_big_loc(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               4,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               Qnil,
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_big_key(ojParser p) {
     rb_funcall((VALUE)p->ctx,
                oj_add_value_id,
@@ -152,10 +314,20 @@ static void add_big_key(ojParser p) {
                get_key(p));
 }
 
+static void add_big_key_loc(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               4,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               get_key(p),
+               LONG2FIX(p->line),
+               LONG2FIX(p->cur - p->col));
+}
+
 static void add_str(ojParser p) {
     Delegate       d = (Delegate)p->ctx;
     volatile VALUE rstr;
-    const char *   str = buf_str(&p->buf);
+    const char    *str = buf_str(&p->buf);
     size_t         len = buf_len(&p->buf);
 
     if (d->cache_str < len) {
@@ -166,10 +338,24 @@ static void add_str(ojParser p) {
     rb_funcall(d->handler, oj_add_value_id, 2, rstr, Qnil);
 }
 
+static void add_str_loc(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char    *str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str < len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 4, rstr, Qnil, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void add_str_key(ojParser p) {
     Delegate       d = (Delegate)p->ctx;
     volatile VALUE rstr;
-    const char *   str = buf_str(&p->buf);
+    const char    *str = buf_str(&p->buf);
     size_t         len = buf_len(&p->buf);
 
     if (d->cache_str < len) {
@@ -180,6 +366,20 @@ static void add_str_key(ojParser p) {
     rb_funcall(d->handler, oj_add_value_id, 2, rstr, get_key(p));
 }
 
+static void add_str_key_loc(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char    *str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str < len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 4, rstr, get_key(p), LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
+}
+
 static void reset(ojParser p) {
     Funcs end = p->funcs + 3;
     Funcs f;
@@ -210,53 +410,107 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
         d->handler = value;
         reset(p);
         if (rb_respond_to(value, oj_hash_start_id)) {
-            p->funcs[TOP_FUN].open_object    = open_object;
-            p->funcs[ARRAY_FUN].open_object  = open_object;
-            p->funcs[OBJECT_FUN].open_object = open_object_key;
+            if (1 == rb_obj_method_arity(value, oj_hash_start_id)) {
+                p->funcs[TOP_FUN].open_object    = open_object;
+                p->funcs[ARRAY_FUN].open_object  = open_object;
+                p->funcs[OBJECT_FUN].open_object = open_object_key;
+            } else {
+                p->funcs[TOP_FUN].open_object    = open_object_loc;
+                p->funcs[ARRAY_FUN].open_object  = open_object_loc;
+                p->funcs[OBJECT_FUN].open_object = open_object_loc_key;
+            }
         }
         if (rb_respond_to(value, oj_array_start_id)) {
-            p->funcs[TOP_FUN].open_array    = open_array;
-            p->funcs[ARRAY_FUN].open_array  = open_array;
-            p->funcs[OBJECT_FUN].open_array = open_array_key;
+            if (1 == rb_obj_method_arity(value, oj_array_start_id)) {
+                p->funcs[TOP_FUN].open_array    = open_array;
+                p->funcs[ARRAY_FUN].open_array  = open_array;
+                p->funcs[OBJECT_FUN].open_array = open_array_key;
+            } else {
+                p->funcs[TOP_FUN].open_array    = open_array_loc;
+                p->funcs[ARRAY_FUN].open_array  = open_array_loc;
+                p->funcs[OBJECT_FUN].open_array = open_array_loc_key;
+            }
         }
         if (rb_respond_to(value, oj_hash_end_id)) {
-            p->funcs[TOP_FUN].close_object    = close_object;
-            p->funcs[ARRAY_FUN].close_object  = close_object;
-            p->funcs[OBJECT_FUN].close_object = close_object;
+            if (1 == rb_obj_method_arity(value, oj_hash_end_id)) {
+                p->funcs[TOP_FUN].close_object    = close_object;
+                p->funcs[ARRAY_FUN].close_object  = close_object;
+                p->funcs[OBJECT_FUN].close_object = close_object;
+            } else {
+                p->funcs[TOP_FUN].close_object    = close_object_loc;
+                p->funcs[ARRAY_FUN].close_object  = close_object_loc;
+                p->funcs[OBJECT_FUN].close_object = close_object_loc;
+            }
         }
         if (rb_respond_to(value, oj_array_end_id)) {
-            p->funcs[TOP_FUN].close_array    = close_array;
-            p->funcs[ARRAY_FUN].close_array  = close_array;
-            p->funcs[OBJECT_FUN].close_array = close_array;
+            if (1 == rb_obj_method_arity(value, oj_array_end_id)) {
+                p->funcs[TOP_FUN].close_array    = close_array;
+                p->funcs[ARRAY_FUN].close_array  = close_array;
+                p->funcs[OBJECT_FUN].close_array = close_array;
+            } else {
+                p->funcs[TOP_FUN].close_array    = close_array_loc;
+                p->funcs[ARRAY_FUN].close_array  = close_array_loc;
+                p->funcs[OBJECT_FUN].close_array = close_array_loc;
+            }
         }
         if (rb_respond_to(value, oj_add_value_id)) {
-            p->funcs[TOP_FUN].add_null    = add_null;
-            p->funcs[ARRAY_FUN].add_null  = add_null;
-            p->funcs[OBJECT_FUN].add_null = add_null_key;
-
-            p->funcs[TOP_FUN].add_true    = add_true;
-            p->funcs[ARRAY_FUN].add_true  = add_true;
-            p->funcs[OBJECT_FUN].add_true = add_true_key;
-
-            p->funcs[TOP_FUN].add_false    = add_false;
-            p->funcs[ARRAY_FUN].add_false  = add_false;
-            p->funcs[OBJECT_FUN].add_false = add_false_key;
-
-            p->funcs[TOP_FUN].add_int    = add_int;
-            p->funcs[ARRAY_FUN].add_int  = add_int;
-            p->funcs[OBJECT_FUN].add_int = add_int_key;
-
-            p->funcs[TOP_FUN].add_float    = add_float;
-            p->funcs[ARRAY_FUN].add_float  = add_float;
-            p->funcs[OBJECT_FUN].add_float = add_float_key;
-
-            p->funcs[TOP_FUN].add_big    = add_big;
-            p->funcs[ARRAY_FUN].add_big  = add_big;
-            p->funcs[OBJECT_FUN].add_big = add_big_key;
-
-            p->funcs[TOP_FUN].add_str    = add_str;
-            p->funcs[ARRAY_FUN].add_str  = add_str;
-            p->funcs[OBJECT_FUN].add_str = add_str_key;
+            if (2 == rb_obj_method_arity(value, oj_add_value_id)) {
+                p->funcs[TOP_FUN].add_null    = add_null;
+                p->funcs[ARRAY_FUN].add_null  = add_null;
+                p->funcs[OBJECT_FUN].add_null = add_null_key;
+
+                p->funcs[TOP_FUN].add_true    = add_true;
+                p->funcs[ARRAY_FUN].add_true  = add_true;
+                p->funcs[OBJECT_FUN].add_true = add_true_key;
+
+                p->funcs[TOP_FUN].add_false    = add_false;
+                p->funcs[ARRAY_FUN].add_false  = add_false;
+                p->funcs[OBJECT_FUN].add_false = add_false_key;
+
+                p->funcs[TOP_FUN].add_int    = add_int;
+                p->funcs[ARRAY_FUN].add_int  = add_int;
+                p->funcs[OBJECT_FUN].add_int = add_int_key;
+
+                p->funcs[TOP_FUN].add_float    = add_float;
+                p->funcs[ARRAY_FUN].add_float  = add_float;
+                p->funcs[OBJECT_FUN].add_float = add_float_key;
+
+                p->funcs[TOP_FUN].add_big    = add_big;
+                p->funcs[ARRAY_FUN].add_big  = add_big;
+                p->funcs[OBJECT_FUN].add_big = add_big_key;
+
+                p->funcs[TOP_FUN].add_str    = add_str;
+                p->funcs[ARRAY_FUN].add_str  = add_str;
+                p->funcs[OBJECT_FUN].add_str = add_str_key;
+            } else {
+                p->funcs[TOP_FUN].add_null    = add_null_loc;
+                p->funcs[ARRAY_FUN].add_null  = add_null_loc;
+                p->funcs[OBJECT_FUN].add_null = add_null_key_loc;
+
+                p->funcs[TOP_FUN].add_true    = add_true_loc;
+                p->funcs[ARRAY_FUN].add_true  = add_true_loc;
+                p->funcs[OBJECT_FUN].add_true = add_true_key_loc;
+
+                p->funcs[TOP_FUN].add_false    = add_false_loc;
+                p->funcs[ARRAY_FUN].add_false  = add_false_loc;
+                p->funcs[OBJECT_FUN].add_false = add_false_key_loc;
+
+                p->funcs[TOP_FUN].add_int    = add_int_loc;
+                p->funcs[ARRAY_FUN].add_int  = add_int_loc;
+                p->funcs[OBJECT_FUN].add_int = add_int_key_loc;
+
+                p->funcs[TOP_FUN].add_float    = add_float_loc;
+                p->funcs[ARRAY_FUN].add_float  = add_float_loc;
+                p->funcs[OBJECT_FUN].add_float = add_float_key_loc;
+
+                p->funcs[TOP_FUN].add_big    = add_big_loc;
+                p->funcs[ARRAY_FUN].add_big  = add_big_loc;
+                p->funcs[OBJECT_FUN].add_big = add_big_key_loc;
+
+                p->funcs[TOP_FUN].add_str    = add_str_loc;
+                p->funcs[ARRAY_FUN].add_str  = add_str_loc;
+                p->funcs[OBJECT_FUN].add_str = add_str_key_loc;
+            }
         }
         return Qnil;
     }
@@ -313,7 +567,7 @@ static void mark(ojParser p) {
         return;
     }
     Delegate d = (Delegate)p->ctx;
-    VALUE *kp;
+    VALUE   *kp;
 
     cache_mark(d->str_cache);
     if (Qnil != d->handler) {

data/ext/oj/sparse.c

@@ -953,7 +953,11 @@ CLEANUP:
     }
     stack_cleanup(&pi->stack);
     if (0 != fd) {
+#ifdef _WIN32
+        rb_w32_close(fd);
+#else
         close(fd);
+#endif
     }
     if (err_has(&pi->err)) {
         rb_set_errinfo(Qnil);

data/ext/oj/strict.c

@@ -50,13 +50,13 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
 }
 
 static void hash_end(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
     }
 }
 
 static void array_end(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_array_end(pi, __FILE__, __LINE__);
     }
 }
@@ -66,7 +66,7 @@ static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
 }
 
 static void add_value(ParseInfo pi, VALUE val) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, val);
     }
     pi->stack.head->val = val;
@@ -76,7 +76,7 @@ static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     pi->stack.head->val = rstr;
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
     }
 }
@@ -86,7 +86,7 @@ static void add_num(ParseInfo pi, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     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_number", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }
@@ -95,7 +95,7 @@ static VALUE start_hash(ParseInfo pi) {
     if (Qnil != pi->options.hash_class) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
     }
     return rb_hash_new();
@@ -107,7 +107,7 @@ static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len,
     rb_hash_aset(stack_peek(&pi->stack)->val,
                  oj_calc_hash_key(pi, parent),
                  rstr);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
     }
 }
@@ -122,7 +122,7 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
     rb_hash_aset(stack_peek(&pi->stack)->val,
                  oj_calc_hash_key(pi, parent),
                  v);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, v);
     }
 }
@@ -131,13 +131,13 @@ 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 (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
     }
 }
 
 static VALUE start_array(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
     }
     return rb_ary_new();
@@ -147,7 +147,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
     }
 }
@@ -160,14 +160,14 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     }
     v = oj_num_as_value(ni);
     rb_ary_push(stack_peek(&pi->stack)->val, v);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, v);
     }
 }
 
 static void array_append_value(ParseInfo pi, VALUE value) {
     rb_ary_push(stack_peek(&pi->stack)->val, value);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);
     }
 }

data/ext/oj/validate.c

@@ -2,50 +2,45 @@
 
 #include "parser.h"
 
-static void
-noop(ojParser p) {
+static void noop(ojParser p) {
 }
 
-static VALUE
-option(ojParser p, const char *key, VALUE value) {
+static VALUE option(ojParser p, const char *key, VALUE value) {
     rb_raise(rb_eArgError, "%s is not an option for the validate delegate", key);
     return Qnil;
 }
 
-static VALUE
-result(ojParser p) {
+static VALUE result(ojParser p) {
     return Qnil;
 }
 
-static void
-dfree(ojParser p) {
+static void dfree(ojParser p) {
 }
 
-static void
-mark(ojParser p) {
+static void mark(ojParser p) {
 }
 
 void oj_set_parser_validator(ojParser p) {
-    p->ctx = NULL;
-    Funcs	end = p->funcs + 3;
+    Funcs end = p->funcs + 3;
     Funcs f;
+    p->ctx = NULL;
 
     for (f = p->funcs; f < end; f++) {
-	f->add_null = noop;
-	f->add_true = noop;
-	f->add_false = noop;
-	f->add_int = noop;
-	f->add_float = noop;
-	f->add_big = noop;
-	f->add_str = noop;
-	f->open_array = noop;
-	f->close_array = noop;
-	f->open_object = noop;
-	f->close_object = noop;
+        f->add_null     = noop;
+        f->add_true     = noop;
+        f->add_false    = noop;
+        f->add_int      = noop;
+        f->add_float    = noop;
+        f->add_big      = noop;
+        f->add_str      = noop;
+        f->open_array   = noop;
+        f->close_array  = noop;
+        f->open_object  = noop;
+        f->close_object = noop;
     }
     p->option = option;
     p->result = result;
-    p->free = dfree;
-    p->mark = mark;
-    p->start = noop;
+    p->free   = dfree;
+    p->mark   = mark;
+    p->start  = noop;
 }