oj 3.13.17 → 3.16.3

data/ext/oj/compat.c

@@ -6,38 +6,26 @@
 #include "encode.h"
 #include "err.h"
 #include "intern.h"
+#include "mem.h"
 #include "oj.h"
 #include "parse.h"
 #include "resolve.h"
 #include "trace.h"
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->classname = oj_strndup(str, len);
         parent->clen      = len;
     } else {
         volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes != pi->options.cache_keys) {
-                if (Yes == pi->options.sym_key) {
-                    rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-                } else {
-		    rkey = rb_utf8_str_new(key, klen);
-                }
-            } else if (Yes == pi->options.sym_key) {
-                rkey = oj_sym_intern(key, klen);
-            } else {
-                rkey = oj_str_intern(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 
@@ -54,9 +42,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         } else {
             rb_hash_aset(parent->val, rkey, rstr);
         }
-        if (RB_UNLIKELY(Yes == pi->options.trace)) {
-            oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
-        }
+        TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
     }
 }
 
@@ -68,9 +54,7 @@ static VALUE start_hash(ParseInfo pi) {
     } else {
         h = rb_hash_new();
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
     return h;
 }
 
@@ -89,13 +73,11 @@ static void end_hash(struct _parseInfo *pi) {
             }
         }
         if (0 != parent->classname) {
-            xfree((char *)parent->classname);
+            OJ_R_FREE((char *)parent->classname);
             parent->classname = 0;
         }
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
@@ -110,37 +92,27 @@ static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig
         }
     }
     pi->stack.head->val = rstr;
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, rstr);
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
     pi->stack.head->val = oj_num_as_value(ni);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, pi->stack.head->val);
 }
 
 static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
-    if (!oj_use_hash_alt && rb_cHash != rb_obj_class(parent->val)) {
+    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
         // the unit tests.
-        rb_funcall(stack_peek(&pi->stack)->val,
-                   rb_intern("[]="),
-                   2,
-                   oj_calc_hash_key(pi, parent),
-                   rval);
+        rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, oj_calc_hash_key(pi, parent), rval);
     } else {
         rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rval);
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, rval);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
@@ -149,26 +121,18 @@ static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail
         // the unit tests.
-        rb_funcall(stack_peek(&pi->stack)->val,
-                   rb_intern("[]="),
-                   2,
-                   oj_calc_hash_key(pi, parent),
-                   value);
+        rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, oj_calc_hash_key(pi, parent), value);
     } else {
         rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 
 static VALUE start_array(ParseInfo pi) {
     if (Qnil != pi->options.array_class) {
         return rb_class_new_instance(0, NULL, pi->options.array_class);
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_array", pi);
     return rb_ary_new();
 }
 
@@ -184,9 +148,7 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     } else {
         rb_ary_push(parent->val, rval);
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
@@ -201,9 +163,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
         }
     }
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
 void oj_set_compat_callbacks(ParseInfo pi) {

data/ext/oj/custom.c

@@ -9,6 +9,7 @@
 #include "encode.h"
 #include "err.h"
 #include "intern.h"
+#include "mem.h"
 #include "odd.h"
 #include "oj.h"
 #include "parse.h"
@@ -24,21 +25,21 @@ static void dump_obj_str(VALUE obj, int depth, Out out) {
         {"s", 1, Qnil},
         {NULL, 0, Qnil},
     };
-    attrs->value = rb_funcall(obj, oj_to_s_id, 0);
+    attrs->value = oj_safe_string_convert(obj);
 
     oj_code_attrs(obj, attrs, depth, out, Yes == out->opts->create_ok);
 }
 
 static void dump_obj_as_str(VALUE obj, int depth, Out out) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-    const char *   str  = RSTRING_PTR(rstr);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
+    const char    *str  = RSTRING_PTR(rstr);
 
     oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
 }
 
 static void bigdecimal_dump(VALUE obj, int depth, Out out) {
-    volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-    const char *   str  = RSTRING_PTR(rstr);
+    volatile VALUE rstr = oj_safe_string_convert(obj);
+    const char    *str  = RSTRING_PTR(rstr);
     int            len  = (int)RSTRING_LEN(rstr);
 
     if (0 == strcasecmp("Infinity", str)) {
@@ -82,8 +83,7 @@ static VALUE complex_load(VALUE clas, VALUE args) {
         real_id = rb_intern("real");
         imag_id = rb_intern("imag");
     }
-    return rb_complex_new(rb_hash_aref(args, rb_id2str(real_id)),
-                          rb_hash_aref(args, rb_id2str(imag_id)));
+    return rb_complex_new(rb_hash_aref(args, rb_id2str(real_id)), rb_hash_aref(args, rb_id2str(imag_id)));
 }
 
 static void time_dump(VALUE obj, int depth, Out out) {
@@ -246,8 +246,7 @@ static VALUE rational_load(VALUE clas, VALUE args) {
         numerator_id   = rb_intern("numerator");
         denominator_id = rb_intern("denominator");
     }
-    return rb_rational_new(rb_hash_aref(args, rb_id2str(numerator_id)),
-                           rb_hash_aref(args, rb_id2str(denominator_id)));
+    return rb_rational_new(rb_hash_aref(args, rb_id2str(numerator_id)), rb_hash_aref(args, rb_id2str(denominator_id)));
 }
 
 static VALUE regexp_load(VALUE clas, VALUE args) {
@@ -292,8 +291,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         assure_size(out, depth * out->indent + 1);
         fill_indent(out, depth);
     } else {
-        assure_size(out,
-                    depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
+        assure_size(out, depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
         if (0 < out->opts->dump_opts.hash_size) {
             APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
         }
@@ -308,7 +306,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     switch (rb_type(key)) {
     case T_STRING: oj_dump_str(key, 0, out, false); break;
     case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
-    default: oj_dump_str(rb_funcall(key, oj_to_s_id, 0), 0, out, false); break;
+    default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
     }
     if (!out->opts->dump_opts.use) {
         *out->cur++ = ':';
@@ -352,9 +350,7 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             assure_size(out, depth * out->indent + 2);
             fill_indent(out, depth);
         } else {
-            assure_size(
-                out,
-                depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
+            assure_size(out, depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
             if (0 < out->opts->dump_opts.hash_size) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
             }
@@ -372,10 +368,10 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
-    ID *           idp;
-    AttrGetFunc *  fp;
+    ID            *idp;
+    AttrGetFunc   *fp;
     volatile VALUE v;
-    const char *   name;
+    const char    *name;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -384,7 +380,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
     if (NULL != out->opts->create_id && Yes == out->opts->create_ok) {
         const char *classname = rb_class2name(clas);
         int         clen      = (int)strlen(classname);
-        size_t sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+        size_t      sep_len   = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
 
         size = d2 * out->indent + 10 + clen + out->opts->create_id_len + sep_len;
         assure_size(out, size);
@@ -442,7 +438,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
                 ID    i;
 
                 if (sizeof(nbuf) <= nlen) {
-                    if (NULL == (n2 = strdup(name))) {
+                    if (NULL == (n2 = OJ_STRDUP(name))) {
                         rb_raise(rb_eNoMemError, "for attribute name.");
                     }
                 } else {
@@ -459,7 +455,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
                 i = rb_intern(n);
                 v = rb_funcall(v, i, 0);
                 if (nbuf != n2) {
-                    free(n2);
+                    OJ_FREE(n2);
                 }
             }
             fill_indent(out, d2);
@@ -481,20 +477,16 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         oj_dump_raw_json(obj, depth, out);
     } else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
         volatile VALUE rs;
-        const char *   s;
+        const char    *s;
         int            len;
 
-        if (Yes == out->opts->trace) {
-            oj_trace("to_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyIn);
-        }
+        TRACE(out->opts->trace, "to_json", obj, depth + 1, TraceRubyIn);
         if (0 == rb_obj_method_arity(obj, oj_to_json_id)) {
             rs = rb_funcall(obj, oj_to_json_id, 0);
         } else {
             rs = rb_funcall2(obj, oj_to_json_id, out->argc, out->argv);
         }
-        if (Yes == out->opts->trace) {
-            oj_trace("to_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
-        }
+        TRACE(out->opts->trace, "to_json", obj, depth + 1, TraceRubyOut);
         s   = RSTRING_PTR(rs);
         len = (int)RSTRING_LEN(rs);
 
@@ -504,9 +496,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
     } else if (Yes == out->opts->as_json && rb_respond_to(obj, oj_as_json_id)) {
         volatile VALUE aj;
 
-        if (Yes == out->opts->trace) {
-            oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyIn);
-        }
+        TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyIn);
         // Some classes elect to not take an options argument so check the arity
         // of as_json.
         if (0 == rb_obj_method_arity(obj, oj_as_json_id)) {
@@ -514,18 +504,12 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         } else {
             aj = rb_funcall2(obj, oj_as_json_id, out->argc, out->argv);
         }
-        if (Yes == out->opts->trace) {
-            oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
-        }
+        TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyOut);
         // Catch the obvious brain damaged recursive dumping.
         if (aj == obj) {
-            volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+            volatile VALUE rstr = oj_safe_string_convert(obj);
 
-            oj_dump_cstr(RSTRING_PTR(rstr),
-                         (int)RSTRING_LEN(rstr),
-                         false,
-                         false,
-                         out);
+            oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), false, false, out);
         } else {
             oj_dump_custom_val(aj, depth, out, true);
         }
@@ -609,7 +593,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
     assure_size(out, 2);
     *out->cur++ = '{';
     if (Qundef != clas && NULL != out->opts->create_id && Yes == out->opts->create_ok) {
-        size_t sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+        size_t      sep_len   = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         const char *classname = rb_obj_classname(obj);
         size_t      len       = strlen(classname);
 
@@ -885,9 +869,7 @@ static DumpFunc custom_funcs[] = {
 void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
     int type = rb_type(obj);
 
-    if (Yes == out->opts->trace) {
-        oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
-    }
+    TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
     if (MAX_DEPTH < depth) {
         rb_raise(rb_eNoMemError, "Too deeply nested.\n");
     }
@@ -896,27 +878,22 @@ void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
 
         if (NULL != f) {
             f(obj, depth, out, true);
-            if (Yes == out->opts->trace) {
-                oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
-            }
+            TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
             return;
         }
     }
     oj_dump_nil(Qnil, depth, out, false);
-    if (Yes == out->opts->trace) {
-        oj_trace("dump", Qnil, __FILE__, __LINE__, depth, TraceOut);
-    }
+    TRACE(out->opts->trace, "dump", Qnil, depth, TraceOut);
 }
 
 ///// load functions /////
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->clas = oj_name2class(pi, str, len, false, rb_eArgError);
@@ -928,16 +905,9 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
             }
         }
     } else {
-	volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
-        //volatile VALUE rstr = rb_utf8_str_new(str, len);
+        volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes == pi->options.sym_key) {
-                rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-            } else {
-		rkey = rb_utf8_str_new(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 
@@ -959,9 +929,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
             break;
         default: break;
         }
-        if (RB_UNLIKELY(Yes == pi->options.trace)) {
-            oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
-        }
+        TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
     }
 }
 
@@ -978,9 +946,7 @@ static void end_hash(struct _parseInfo *pi) {
         }
         parent->clas = Qundef;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
@@ -1008,20 +974,10 @@ static void hash_set_num(struct _parseInfo *pi, 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(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);
             }
@@ -1032,9 +988,7 @@ static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
         break;
     default: break;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rval);
 }
 
 static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
@@ -1045,9 +999,7 @@ static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
     case T_HASH: rb_hash_aset(parent->val, oj_calc_hash_key(pi, kval), value); break;
     default: break;
     }
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 
 static void array_append_num(ParseInfo pi, NumInfo ni) {
@@ -1055,9 +1007,7 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     volatile VALUE rval   = oj_num_as_value(ni);
 
     rb_ary_push(parent->val, rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
@@ -1072,9 +1022,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
         }
     }
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
 void oj_set_custom_callbacks(ParseInfo pi) {

data/ext/oj/debug.c

@@ -30,9 +30,7 @@ static void add_int(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_int %lld at top\n", (long long)p->num.fixnum); break;
     case ARRAY_FUN: printf("*** add_int %lld to array\n", (long long)p->num.fixnum); break;
-    case OBJECT_FUN:
-        printf("*** add_int %lld with '%s'\n", (long long)p->num.fixnum, buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_int %lld with '%s'\n", (long long)p->num.fixnum, buf_str(&p->key)); break;
     }
 }
 
@@ -48,9 +46,7 @@ static void add_big(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_big %s at top\n", buf_str(&p->buf)); break;
     case ARRAY_FUN: printf("*** add_big %s to array\n", buf_str(&p->buf)); break;
-    case OBJECT_FUN:
-        printf("*** add_big %s with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_big %s with '%s'\n", buf_str(&p->buf), buf_str(&p->key)); break;
     }
 }
 
@@ -58,9 +54,7 @@ static void add_str(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_str '%s' at top\n", buf_str(&p->buf)); break;
     case ARRAY_FUN: printf("*** add_str '%s' to array\n", buf_str(&p->buf)); break;
-    case OBJECT_FUN:
-        printf("*** add_str '%s' with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_str '%s' with '%s'\n", buf_str(&p->buf), buf_str(&p->key)); break;
     }
 }