oj 3.13.9 → 3.16.1

data/ext/oj/mimic_json.c

@@ -3,6 +3,7 @@
 
 #include "dump.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.h"
 #include "parse.h"
 
@@ -198,7 +199,6 @@ static int mimic_limit_arg(VALUE a) {
  * Returns [_String_] a JSON string.
  */
 static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     struct _options copts = oj_default_options;
     VALUE           rstr;
@@ -206,10 +206,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
-    out.caller        = CALLER_DUMP;
+
+    oj_out_init(&out);
+
     copts.escape_mode = JXEsc;
     copts.mode        = CompatMode;
 
@@ -257,9 +256,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
         rb_funcall2(io, oj_write_id, 1, args);
         rstr = io;
     }
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -272,7 +271,7 @@ static int mimic_walk(VALUE key, VALUE obj, VALUE proc) {
         size_t i;
 
         for (i = 0; i < cnt; i++) {
-            mimic_walk(Qnil, rb_ary_entry(obj, i), proc);
+            mimic_walk(Qnil, RARRAY_AREF(obj, i), proc);
         }
         break;
     }
@@ -349,26 +348,25 @@ static VALUE mimic_load(int argc, VALUE *argv, VALUE self) {
 static VALUE mimic_dump_load(int argc, VALUE *argv, VALUE self) {
     if (1 > argc) {
         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
-    } else if (T_STRING == rb_type(*argv)) {
+    }
+    if (T_STRING == rb_type(*argv)) {
         return mimic_load(argc, argv, self);
-    } else {
-        return mimic_dump(argc, argv, self);
     }
-    return Qnil;
+    return mimic_dump(argc, argv, self);
 }
 
 static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
-    char        buf[4096];
     struct _out out;
     VALUE       rstr;
 
-    memset(buf, 0, sizeof(buf));
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    memset(out.stack_buffer, 0, sizeof(out.stack_buffer));
+
+    oj_out_init(&out);
 
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - 10;
-    out.allocated = false;
-    out.omit_nil  = copts->dump_opts.omit_nil;
-    out.caller    = CALLER_GENERATE;
+    out.omit_nil = copts->dump_opts.omit_nil;
     // For obj.to_json or generate nan is not allowed but if called from dump
     // it is.
     copts->dump_opts.nan_dump = RaiseNan;
@@ -388,6 +386,8 @@ 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);
@@ -398,9 +398,9 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -457,7 +457,10 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     // a Hash. I haven't dug deep enough to find out why but using a State
     // instance and not a Hash gives the desired behavior.
     *rargs = *argv;
-    if (1 == argc) {
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
     } else {
         h = argv[1];
@@ -478,6 +481,8 @@ 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);
@@ -499,6 +504,44 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     return mimic_generate_core(2, rargs, &copts);
 }
 
+static int parse_options_cb(VALUE k, VALUE v, VALUE info) {
+    struct _parseInfo *pi = (struct _parseInfo *)info;
+
+    if (oj_symbolize_names_sym == k) {
+        pi->options.sym_key = (Qtrue == v) ? Yes : No;
+    } else if (oj_quirks_mode_sym == k) {
+        pi->options.quirks_mode = (Qtrue == v) ? Yes : No;
+    } else if (oj_create_additions_sym == k) {
+        pi->options.create_ok = (Qtrue == v) ? Yes : No;
+    } else if (oj_allow_nan_sym == k) {
+        pi->options.allow_nan = (Qtrue == v) ? Yes : No;
+    } else if (oj_hash_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_object_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_array_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.array_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.array_class = v;
+        }
+    } else if (oj_decimal_class_sym == k) {
+        pi->options.compat_bigdec = (oj_bigdecimal_class == v);
+    }
+    return ST_CONTINUE;
+}
+
 static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
     struct _parseInfo pi;
     VALUE             ropts;
@@ -529,46 +572,7 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
         if (T_HASH != rb_type(ropts)) {
             rb_raise(rb_eArgError, "options must be a hash.");
         }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_symbolize_names_sym))) {
-            pi.options.sym_key = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_quirks_mode_sym))) {
-            pi.options.quirks_mode = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_create_additions_sym))) {
-            pi.options.create_ok = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_allow_nan_sym))) {
-            pi.options.allow_nan = (Qtrue == v) ? Yes : No;
-        }
-
-        if (oj_hash_has_key(ropts, oj_hash_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_hash_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_object_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_object_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_array_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_array_class_sym))) {
-                pi.options.array_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.array_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_decimal_class_sym)) {
-            pi.options.compat_bigdec = (oj_bigdecimal_class == rb_hash_lookup(ropts, oj_decimal_class_sym));
-        }
+        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;
@@ -646,23 +650,22 @@ static VALUE mimic_recurse_proc(VALUE self, VALUE obj) {
  *
  * - *id* [_nil_|String] new create_id
  *
- * Returns [_String_] the id.
+ * Returns [_nil_|_String_] the id.
  */
 static VALUE mimic_set_create_id(VALUE self, VALUE id) {
-    Check_Type(id, T_STRING);
-
     if (NULL != oj_default_options.create_id) {
         if (oj_json_class != oj_default_options.create_id) {
-            xfree((char *)oj_default_options.create_id);
+            OJ_R_FREE((char *)oj_default_options.create_id);
         }
         oj_default_options.create_id     = NULL;
         oj_default_options.create_id_len = 0;
     }
     if (Qnil != id) {
-        size_t len = RSTRING_LEN(id) + 1;
+        const char *ptr = StringValueCStr(id);
+        size_t      len = RSTRING_LEN(id) + 1;
 
-        oj_default_options.create_id = ALLOC_N(char, len);
-        strcpy((char *)oj_default_options.create_id, StringValuePtr(id));
+        oj_default_options.create_id = OJ_R_ALLOC_N(char, len);
+        strcpy((char *)oj_default_options.create_id, ptr);
         oj_default_options.create_id_len = len - 1;
     }
     return id;
@@ -732,6 +735,7 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                            0,         // array_size
                                                            RaiseNan,  // nan_dump
                                                            false,     // omit_nil
+                                                           false,     // omit_null_byte
                                                            100,       // max_depth
                                                        },
                                                        {
@@ -742,19 +746,18 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        }};
 
 static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     VALUE           rstr;
     struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
-    out.omit_nil      = copts.dump_opts.omit_nil;
-    copts.mode        = CompatMode;
-    copts.to_json     = No;
+
+    oj_out_init(&out);
+
+    out.omit_nil  = copts.dump_opts.omit_nil;
+    copts.mode    = CompatMode;
+    copts.to_json = No;
     if (1 <= argc && Qnil != argv[0]) {
         oj_parse_mimic_dump_options(argv[0], &copts);
     }
@@ -767,9 +770,9 @@ static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -786,28 +789,48 @@ void oj_mimic_json_methods(VALUE json) {
     VALUE json_error;
     VALUE generator;
     VALUE ext;
+    VALUE verbose;
+
+    // rb_undef_method doesn't work for modules or maybe sometimes
+    // doesn't. Anyway setting verbose should hide the warning.
+    verbose = rb_gv_get("$VERBOSE");
+    rb_gv_set("$VERBOSE", Qfalse);
 
+    rb_undef_method(json, "create_id=");
     rb_define_module_function(json, "create_id=", mimic_set_create_id, 1);
+    rb_undef_method(json, "create_id");
     rb_define_module_function(json, "create_id", mimic_create_id, 0);
 
+    rb_undef_method(json, "dump");
     rb_define_module_function(json, "dump", mimic_dump, -1);
+    rb_undef_method(json, "load");
     rb_define_module_function(json, "load", mimic_load, -1);
     rb_define_module_function(json, "restore", mimic_load, -1);
+    rb_undef_method(json, "recurse_proc");
     rb_define_module_function(json, "recurse_proc", mimic_recurse_proc, 1);
+    rb_undef_method(json, "[]");
     rb_define_module_function(json, "[]", mimic_dump_load, -1);
 
+    rb_undef_method(json, "generate");
     rb_define_module_function(json, "generate", oj_mimic_generate, -1);
+    rb_undef_method(json, "fast_generate");
     rb_define_module_function(json, "fast_generate", oj_mimic_generate, -1);
+    rb_undef_method(json, "pretty_generate");
     rb_define_module_function(json, "pretty_generate", oj_mimic_pretty_generate, -1);
     // For older versions of JSON, the deprecated unparse methods.
+    rb_undef_method(json, "unparse");
     rb_define_module_function(json, "unparse", oj_mimic_generate, -1);
     rb_define_module_function(json, "fast_unparse", oj_mimic_generate, -1);
     rb_define_module_function(json, "pretty_unparse", oj_mimic_pretty_generate, -1);
 
+    rb_undef_method(json, "parse");
     rb_define_module_function(json, "parse", oj_mimic_parse, -1);
+    rb_undef_method(json, "parse!");
     rb_define_module_function(json, "parse!", mimic_parse_bang, -1);
 
+    rb_undef_method(json, "state");
     rb_define_module_function(json, "state", mimic_state, 0);
+    rb_gv_set("$VERBOSE", verbose);
 
     if (rb_const_defined_at(json, rb_intern("JSONError"))) {
         json_error = rb_const_get(json, rb_intern("JSONError"));

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);
                 }
@@ -317,7 +308,7 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
                 return 1;
             }
-            e1 = *RARRAY_PTR(value);
+            e1 = *RARRAY_CONST_PTR(value);
             // check for anonymous Struct
             if (T_ARRAY == rb_type(e1)) {
                 VALUE          args[1024];
@@ -325,46 +316,50 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 int            i, cnt = (int)RARRAY_LEN(e1);
 
                 for (i = 0; i < cnt; i++) {
-                    rstr    = rb_ary_entry(e1, i);
+                    rstr    = RARRAY_AREF(e1, i);
                     args[i] = rb_funcall(rstr, oj_to_sym_id, 0);
                 }
                 sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
             } else {
                 // If struct is not defined then we let this fail and raise an exception.
-                sc = oj_name2struct(pi, *RARRAY_PTR(value), rb_eArgError);
+                sc = oj_name2struct(pi, *RARRAY_CONST_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_CONST_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));
+                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_CONST_PTR(value)[i + 1]);
+                    }
                 }
             }
             return 1;
         } else if (3 <= klen && '#' == key[1]) {
-            volatile VALUE *a;
+            volatile const VALUE *a;
 
             if (2 != len) {
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
                 return 1;
             }
             parent->val = rb_hash_new();
-            a           = RARRAY_PTR(value);
+            a           = RARRAY_CONST_PTR(value);
             rb_hash_aset(parent->val, *a, a[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,11 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (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_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,9 +515,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, rval);
 }
 
 static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
@@ -544,8 +541,8 @@ WHICH_TYPE:
             }
         } else {
             if (3 <= klen && '^' == *key && '#' == key[1] && T_ARRAY == rb_type(value)) {
-                long            len = RARRAY_LEN(value);
-                volatile VALUE *a   = RARRAY_PTR(value);
+                long                  len = RARRAY_LEN(value);
+                volatile const VALUE *a   = RARRAY_CONST_PTR(value);
 
                 if (2 != len) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
@@ -602,15 +599,11 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_value", pi, value);
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
     return Qnil;
 }
 
@@ -626,9 +619,7 @@ static void end_hash(ParseInfo pi) {
         oj_odd_free(oa);
         parent->odd_args = NULL;
     }
-    if (Yes == pi->options.trace) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
@@ -654,32 +645,24 @@ 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) {
-        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rval);
 }
 
 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) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, 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) {
-        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, 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) {
-        oj_trace_parse_call("add_num", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_num", pi, pi->stack.head->val);
 }
 
 void oj_set_object_callbacks(ParseInfo pi) {