oj 3.14.3 → 3.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce52cbfa0a36f659877cda70d0376fdc19264f96ff8ff1f8085e8cb3560c8bae
-  data.tar.gz: 44b94e3e4174f1464dd7b4f025e28110dc273a353c42a4d8460c6e45846d1fab
+  metadata.gz: 257582096951b3c4db4b4979c49afd542ae855ba454bd6d51dcb1a69f68c2405
+  data.tar.gz: d835a958d019f7034e93d3f97ca1829fad74a4e26743f6a8b2b581c03ac9f14a
 SHA512:
-  metadata.gz: 465dd87a8c8e11b562de10d1ab60d78f8e2250c4c06f997455673ea67fb88c75e1c07dea01c01fa864ebfa39a2b0bee1371ee7551895ba6d125bee3af20975ee
-  data.tar.gz: 430a1f0a293fe87fd03af88b2e1f27e70ffae7b7ab8a2451dea1de5891ce6b9967f5475bd33f7cb37c728a7e4ed44b2b3c5051ebeb452c76f393f543a42d5dd1
+  metadata.gz: 374e55547de2db4b2199c05bebe5fa74953021883f7f609e328466c076016817b0cb8a7be03ead9c68b3fe4895eb5de0bcd60e1384ff7f1a5f7cd480824faba0
+  data.tar.gz: ec9cf41116602a51c49ff73ba6fc39ecbb501d51cbab0a6065bb38d2ac15a7f42332dc66f0d97df40bea6da5fafbc15209d06039180829c4c4b299b0e138676e

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+## 3.15.1 - 2023-07-30
+
+- Add protection against some using `require 'oj/json`, an internal file.
+
+- Fixed non-json errors when in compat mode.
+
+## 3.15.0 - 2023-06-02
+
+- Added `omit_null_byte` option when dumping.
+
 ## 3.14.3 - 2023-04-07
 
 - Fixed compat parse with optimized Hash when parsing a JSON::GenericObject.

data/ext/oj/code.c

@@ -185,24 +185,17 @@ void oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out, bool with_class) {
             } else {
                 char   buf[32];
                 char  *b   = buf + sizeof(buf) - 1;
-                int    neg = 0;
+                bool   neg = false;
                 long   num = attrs->num;
                 size_t cnt = 0;
 
                 if (0 > num) {
-                    neg = 1;
+                    neg = true;
                     num = -num;
                 }
                 *b-- = '\0';
                 if (0 < num) {
-                    for (; 0 < num; num /= 10, b--) {
-                        *b = (num % 10) + '0';
-                    }
-                    if (neg) {
-                        *b = '-';
-                    } else {
-                        b++;
-                    }
+                    b = oj_longlong_to_string(num, neg, b);
                 } else {
                     *b = '0';
                 }

data/ext/oj/compat.c

@@ -13,32 +13,19 @@
 #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);
 

data/ext/oj/custom.c

@@ -889,12 +889,11 @@ void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
 ///// 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);
@@ -907,15 +906,8 @@ 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 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);
 
@@ -937,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);
     }
 }
 
@@ -998,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) {
@@ -1011,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) {
@@ -1021,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) {
@@ -1038,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/dump.c

@@ -857,6 +857,9 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                 break;
             case '6':  // control characters
                 if (*(uint8_t *)str < 0x80) {
+                    if (0 == (uint8_t)*str && out->opts->dump_opts.omit_null_byte) {
+                        break;
+                    }
                     APPEND_CHARS(out->cur, "\\u00", 4);
                     dump_hex((uint8_t)*str, out);
                 } else {
@@ -995,11 +998,45 @@ void oj_dump_false(VALUE obj, int depth, Out out, bool as_ok) {
     *out->cur = '\0';
 }
 
+static const char digits_table[] = "\
+00010203040506070809\
+10111213141516171819\
+20212223242526272829\
+30313233343536373839\
+40414243444546474849\
+50515253545556575859\
+60616263646566676869\
+70717273747576777879\
+80818283848586878889\
+90919293949596979899";
+
+char *oj_longlong_to_string(long long num, bool negative, char *buf) {
+    while (100 <= num) {
+        unsigned idx = num % 100 * 2;
+        *buf--       = digits_table[idx + 1];
+        *buf--       = digits_table[idx];
+        num /= 100;
+    }
+    if (num < 10) {
+        *buf-- = num + '0';
+    } else {
+        *buf-- = digits_table[num * 2 + 1];
+        *buf-- = digits_table[num * 2];
+    }
+
+    if (negative) {
+        *buf = '-';
+    } else {
+        buf++;
+    }
+    return buf;
+}
+
 void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
     char      buf[32];
     char     *b              = buf + sizeof(buf) - 1;
     long long num            = NUM2LL(obj);
-    int       neg            = 0;
+    bool      neg            = false;
     size_t    cnt            = 0;
     bool      dump_as_string = false;
 
@@ -1008,7 +1045,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         dump_as_string = true;
     }
     if (0 > num) {
-        neg = 1;
+        neg = true;
         num = -num;
     }
     *b-- = '\0';
@@ -1017,14 +1054,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         *b-- = '"';
     }
     if (0 < num) {
-        for (; 0 < num; num /= 10, b--) {
-            *b = (num % 10) + '0';
-        }
-        if (neg) {
-            *b = '-';
-        } else {
-            b++;
-        }
+        b = oj_longlong_to_string(num, neg, b);
     } else {
         *b = '0';
     }

data/ext/oj/dump.h

@@ -93,10 +93,7 @@ inline static void dump_ulong(unsigned long num, Out out) {
 
     *b-- = '\0';
     if (0 < num) {
-        for (; 0 < num; num /= 10, b--) {
-            *b = (num % 10) + '0';
-        }
-        b++;
+        b = oj_longlong_to_string((long long)num, false, b);
     } else {
         *b = '0';
     }

data/ext/oj/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 require 'rbconfig'
 
@@ -6,7 +8,7 @@ dir_config(extension_name)
 
 parts = RUBY_DESCRIPTION.split(' ')
 type = parts[0]
-type = type[4..-1] if type.start_with?('tcs-')
+type = type[4..] if type.start_with?('tcs-')
 is_windows = RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
 platform = RUBY_PLATFORM
 version = RUBY_VERSION.split('.')
@@ -56,7 +58,7 @@ dflags.each do |k, v|
 end
 
 $CPPFLAGS += ' -Wall'
-#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
 # Adding the __attribute__ flag only works with gcc compilers and even then it
 # does not work to check args with varargs so just remove the check.
 CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)

data/ext/oj/fast.c

@@ -40,7 +40,7 @@ typedef struct _doc {
     Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
     char         *json;
-    unsigned long size;  // number of leaves/branches in the doc
+    unsigned long size;                   // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
@@ -114,10 +114,7 @@ inline static char *ulong_fill(char *s, size_t num) {
     char *b = buf + sizeof(buf) - 1;
 
     *b-- = '\0';
-    for (; 0 < num; num /= 10, b--) {
-        *b = (num % 10) + '0';
-    }
-    b++;
+    b    = oj_longlong_to_string((long long)num, false, b);
     if ('\0' == *b) {
         b--;
         *b = '0';
@@ -576,7 +573,7 @@ static char *read_quoted_value(ParseInfo pi) {
     char *h     = pi->s;  // head
     char *t     = h;      // tail
 
-    h++;  // skip quote character
+    h++;                  // skip quote character
     t++;
     value = h;
     for (; '"' != *h; h++, t++) {

data/ext/oj/mimic_json.c

@@ -574,7 +574,6 @@ 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.");
         }
-
         rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
         v = rb_hash_lookup(ropts, oj_max_nesting_sym);
         if (Qtrue == v) {
@@ -738,6 +737,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
                                                        },
                                                        {
@@ -791,28 +791,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

@@ -446,9 +446,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    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_num(ParseInfo pi, Val kval, NumInfo ni) {
@@ -517,9 +515,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (RB_UNLIKELY(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) {
@@ -603,9 +599,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (RB_UNLIKELY(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) {
@@ -651,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 (RB_UNLIKELY(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 (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 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 (RB_UNLIKELY(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 (RB_UNLIKELY(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) {

data/ext/oj/oj.c

@@ -135,6 +135,7 @@ static VALUE newline_sym;
 static VALUE nilnil_sym;
 static VALUE null_sym;
 static VALUE object_sym;
+static VALUE omit_null_byte_sym;
 static VALUE omit_nil_sym;
 static VALUE rails_sym;
 static VALUE raise_sym;
@@ -222,6 +223,7 @@ struct _options oj_default_options = {
         0,          // array_size
         AutoNan,    // nan_dump
         false,      // omit_nil
+        false,      // omit_null_byte
         MAX_DEPTH,  // max_depth
     },
     {
@@ -230,7 +232,7 @@ struct _options oj_default_options = {
         NULL,    // tail
         {'\0'},  // err
     },
-    NULL,  // ignore
+    NULL,        // ignore
 };
 
 /* Document-method: default_options()
@@ -291,6 +293,7 @@ struct _options oj_default_options = {
  *used
  * - *:array_class* [_Class_|_nil_] Class to use instead of Array on load
  * - *:omit_nil* [_true_|_false_] if true Hash and Object attributes with nil values are omitted
+ * - *:omit_null_byte* [_true_|_false_] if true null bytes in strings will be omitted when dumping
  * - *:ignore* [_nil_|_Array_] either nil or an Array of classes to ignore when dumping
  * - *:ignore_under* [_Boolean_] if true then attributes that start with _ are ignored when dumping in
  *object or custom mode.
@@ -384,6 +387,7 @@ static VALUE get_def_opts(VALUE self) {
         opts,
         cache_keys_sym,
         (Yes == oj_default_options.cache_keys) ? Qtrue : ((No == oj_default_options.cache_keys) ? Qfalse : Qnil));
+
     switch (oj_default_options.mode) {
     case StrictMode: rb_hash_aset(opts, mode_sym, strict_sym); break;
     case CompatMode: rb_hash_aset(opts, mode_sym, compat_sym); break;
@@ -459,6 +463,7 @@ static VALUE get_def_opts(VALUE self) {
     default: rb_hash_aset(opts, nan_sym, auto_sym); break;
     }
     rb_hash_aset(opts, omit_nil_sym, oj_default_options.dump_opts.omit_nil ? Qtrue : Qfalse);
+    rb_hash_aset(opts, omit_null_byte_sym, oj_default_options.dump_opts.omit_null_byte ? Qtrue : Qfalse);
     rb_hash_aset(opts, oj_hash_class_sym, oj_default_options.hash_class);
     rb_hash_aset(opts, oj_array_class_sym, oj_default_options.array_class);
 
@@ -865,6 +870,17 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         } else {
             rb_raise(rb_eArgError, ":omit_nil must be true or false.");
         }
+    } else if (omit_null_byte_sym == k) {
+        if (Qnil == v) {
+            return ST_CONTINUE;
+        }
+        if (Qtrue == v) {
+            copts->dump_opts.omit_null_byte = true;
+        } else if (Qfalse == v) {
+            copts->dump_opts.omit_null_byte = false;
+        } else {
+            rb_raise(rb_eArgError, ":omit_null_byte must be true or false.");
+        }
     } else if (oj_ascii_only_sym == k) {
         // This is here only for backwards compatibility with the original Oj.
         if (Qtrue == v) {
@@ -1278,8 +1294,9 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(arg.out);
 
-    arg.out->omit_nil = copts.dump_opts.omit_nil;
-    arg.out->caller   = CALLER_DUMP;
+    arg.out->omit_nil       = copts.dump_opts.omit_nil;
+    arg.out->omit_null_byte = copts.dump_opts.omit_null_byte;
+    arg.out->caller         = CALLER_DUMP;
 
     return rb_ensure(dump_body, (VALUE)&arg, dump_ensure, (VALUE)&arg);
 }
@@ -1326,7 +1343,8 @@ static VALUE to_json(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(&out);
 
-    out.omit_nil = copts.dump_opts.omit_nil;
+    out.omit_nil       = copts.dump_opts.omit_nil;
+    out.omit_null_byte = copts.dump_opts.omit_null_byte;
     // For obj.to_json or generate nan is not allowed but if called from dump
     // it is.
     oj_dump_obj_to_json_using_params(*argv, &copts, &out, argc - 1, argv + 1);
@@ -1967,6 +1985,8 @@ void Init_oj(void) {
     rb_gc_register_address(&oj_quirks_mode_sym);
     oj_safe_sym = ID2SYM(rb_intern("safe"));
     rb_gc_register_address(&oj_safe_sym);
+    omit_null_byte_sym = ID2SYM(rb_intern("omit_null_byte"));
+    rb_gc_register_address(&omit_null_byte_sym);
     oj_space_before_sym = ID2SYM(rb_intern("space_before"));
     rb_gc_register_address(&oj_space_before_sym);
     oj_space_sym = ID2SYM(rb_intern("space"));

data/ext/oj/oj.h

@@ -124,6 +124,7 @@ typedef struct _dumpOpts {
     uint8_t array_size;
     char    nan_dump;  // NanDump
     bool    omit_nil;
+    bool    omit_null_byte;
     int     max_depth;
 } *DumpOpts;
 
@@ -199,6 +200,7 @@ typedef struct _out {
     uint32_t   hash_cnt;
     bool       allocated;
     bool       omit_nil;
+    bool       omit_null_byte;
     int        argc;
     VALUE     *argv;
     DumpCaller caller;  // used for the mimic json only
@@ -260,12 +262,13 @@ extern VALUE oj_custom_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 extern bool oj_hash_has_key(VALUE hash, VALUE key);
 extern void oj_parse_options(VALUE ropts, Options copts);
 
-extern void oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
-extern void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);
-extern void oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
-extern void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
-extern void oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
-extern void oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
+extern void  oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
+extern void  oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);
+extern void  oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
+extern void  oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
+extern void  oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
+extern void  oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
+extern char *oj_longlong_to_string(long long num, bool negative, char *buf);
 
 extern void oj_str_writer_push_key(StrWriter sw, const char *key);
 extern void oj_str_writer_push_object(StrWriter sw, const char *key);
@@ -323,6 +326,7 @@ extern VALUE oj_max_nesting_sym;
 extern VALUE oj_object_class_sym;
 extern VALUE oj_object_nl_sym;
 extern VALUE oj_quirks_mode_sym;
+extern VALUE oj_skip_null_byte_sym;
 extern VALUE oj_space_before_sym;
 extern VALUE oj_space_sym;
 extern VALUE oj_symbolize_names_sym;

data/ext/oj/parse.c

@@ -426,6 +426,7 @@ static void read_num(ParseInfo pi) {
     struct _numInfo ni;
     Val             parent = stack_peek(&pi->stack);
 
+    ni.pi       = pi;
     ni.str      = pi->cur;
     ni.i        = 0;
     ni.num      = 0;
@@ -709,10 +710,7 @@ void oj_parse2(ParseInfo pi) {
         case '[': array_start(pi); break;
         case ']': array_end(pi); break;
         case ',': comma(pi); break;
-        case '"':
-            read_str(pi);
-            break;
-            // case '+':
+        case '"': read_str(pi); break;
         case '+':
             if (CompatMode == pi->options.mode) {
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
@@ -877,7 +875,7 @@ oj_num_as_value(NumInfo ni) {
             double d = strtod(ni->str, &end);
 
             if ((long)ni->len != (long)(end - ni->str)) {
-                rb_raise(oj_parse_error_class, "Invalid float");
+                rb_raise(ni->pi->err_class, "Invalid float");
             }
             rnum = rb_float_new(d);
         }