oj 3.17.7 → 3.17.8

data/ext/oj/mimic_json.c

@@ -241,12 +241,7 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
     // default ::JSON::State argument is passed in. Basically a hack to get
     // around the active support hack so two wrongs make a right this time.
     active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
-    oj_dump_obj_to_json_using_params(*argv, &copts, &out, 1, active_hack);
-
-    if (0 == out.buf) {
-        rb_raise(rb_eNoMemError, "Not enough memory.");
-    }
-    rstr = rb_utf8_str_new_cstr(out.buf);
+    rstr           = oj_dump_obj_to_str(*argv, &copts, &out, 1, active_hack);
     if (2 <= argc && Qnil != argv[1] && rb_respond_to(argv[1], oj_write_id)) {
         VALUE io = argv[1];
         VALUE args[1];
@@ -255,9 +250,6 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
         rb_funcall2(io, oj_write_id, 1, args);
         rstr = io;
     }
-
-    oj_out_free(&out);
-
     return rstr;
 }
 
@@ -380,7 +372,7 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     }
     */
     if (1 < argc) {
-        oj_dump_obj_to_json_using_params(*argv, copts, &out, argc - 1, argv + 1);
+        rstr = oj_dump_obj_to_str(*argv, copts, &out, argc - 1, argv + 1);
     } else {
         VALUE active_hack[1];
 
@@ -390,15 +382,8 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
             oj_define_mimic_json(0, NULL, Qnil);
         }
         active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
-        oj_dump_obj_to_json_using_params(*argv, copts, &out, 1, active_hack);
-    }
-    if (0 == out.buf) {
-        rb_raise(rb_eNoMemError, "Not enough memory.");
+        rstr           = oj_dump_obj_to_str(*argv, copts, &out, 1, active_hack);
     }
-    rstr = rb_utf8_str_new_cstr(out.buf);
-
-    oj_out_free(&out);
-
     return rstr;
 }
 
@@ -748,7 +733,6 @@ static struct _options mimic_object_to_json_options = {0,              // indent
 
 static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     struct _out     out;
-    VALUE           rstr;
     struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
@@ -765,15 +749,7 @@ static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     // To be strict the mimic_object_to_json_options should be used but people
     // seem to prefer the option of changing that.
     // oj_dump_obj_to_json(self, &mimic_object_to_json_options, &out);
-    oj_dump_obj_to_json_using_params(self, &copts, &out, argc, argv);
-    if (NULL == out.buf) {
-        rb_raise(rb_eNoMemError, "Not enough memory.");
-    }
-    rstr = rb_utf8_str_new_cstr(out.buf);
-
-    oj_out_free(&out);
-
-    return rstr;
+    return oj_dump_obj_to_str(self, &copts, &out, argc, argv);
 }
 
 /* Document-method: state

data/ext/oj/object.c

@@ -213,8 +213,12 @@ static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t
         switch (key[1]) {
         case 'o':  // object
         {          // name2class sets an error if the class is not found or created
-            VALUE clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define, rb_eArgError);
+            VALUE clas;
 
+            if (oj_is_backtrace_name(str, len)) {
+                break;
+            }
+            clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define, rb_eArgError);
             if (Qundef != clas) {
                 parent->val = rb_obj_alloc(clas);
             }
@@ -346,9 +350,23 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
             }
             if (sc == rb_cRange) {
                 parent->val = rb_class_new_instance((int)(len - 1), RARRAY_CONST_PTR(value) + 1, rb_cRange);
+            } else if (Qtrue == rb_class_inherited_p(sc, rb_cRange)) {
+                volatile VALUE args = rb_ary_new_from_values((long)len, RARRAY_CONST_PTR(value));
+                volatile VALUE init = rb_funcall(rb_cRange,
+                                                 rb_intern("instance_method"),
+                                                 1,
+                                                 ID2SYM(rb_intern("initialize")));
+
+                parent->val = rb_obj_alloc(sc);
+                rb_ary_store(args, 0, parent->val);
+                rb_apply(init, rb_intern("bind_call"), args);
             } else {
                 // Create a properly initialized struct instance without calling the initialize method.
                 parent->val = rb_obj_alloc(sc);
+                if (T_STRUCT != rb_type(parent->val)) {
+                    oj_set_error_at(pi, rb_eArgError, __FILE__, __LINE__, "%s is not a Struct", rb_class2name(sc));
+                    return 1;
+                }
                 // 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
@@ -393,7 +411,8 @@ void oj_set_obj_ivar(Val parent, Val kval, VALUE value) {
         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 {
+    } else if (kval->klen != 13 || strncmp("~bt_locations", kval->key, 13) != 0 ||
+               !rb_obj_is_kind_of(parent->val, rb_eException)) {
         rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
     }
 }

data/ext/oj/oj.c

@@ -1589,7 +1589,7 @@ static VALUE load_file(int argc, VALUE *argv, VALUE self) {
     if (1 > argc) {
         rb_raise(rb_eArgError, "Wrong number of arguments to load().");
     }
-    path = StringValuePtr(*argv);
+    path = StringValueCStr(*argv);
     parse_info_init(&pi);
     pi.options   = oj_default_options;
     pi.handler   = Qnil;
@@ -1799,7 +1799,6 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
 static VALUE to_json(int argc, VALUE *argv, VALUE self) {
     struct _out     out;
     struct _options copts = oj_default_options;
-    VALUE           rstr;
 
     if (1 > argc) {
         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
@@ -1818,16 +1817,71 @@ static VALUE to_json(int argc, VALUE *argv, VALUE self) {
     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);
+    return oj_dump_obj_to_str(*argv, &copts, &out, argc - 1, argv + 1);
+}
 
-    if (0 == out.buf) {
-        rb_raise(rb_eNoMemError, "Not enough memory.");
+struct option_buffers {
+    const char *create_id;
+    VALUE      *ignore;
+    const char *only;
+    const char *except;
+};
+
+struct write_call_arg {
+    Options               copts;
+    int                   argc;
+    VALUE                *argv;
+    struct option_buffers base;
+    struct option_buffers own;
+    bool                  owned;
+};
+
+static void option_buffers_get(Options copts, struct option_buffers *bufs) {
+    bufs->create_id = copts->create_id;
+    bufs->ignore    = copts->ignore;
+    bufs->only      = copts->dump_opts.only;
+    bufs->except    = copts->dump_opts.except;
+}
+
+static void write_call_options(struct write_call_arg *arg) {
+    oj_options_take_ownership(arg->copts);
+    option_buffers_get(arg->copts, &arg->own);
+    arg->owned = true;
+    if (3 == arg->argc) {
+        oj_parse_options(arg->argv[2], arg->copts);
     }
-    rstr = rb_utf8_str_new_cstr(out.buf);
+}
 
-    oj_out_free(&out);
+static void free_call_buffer(const void *cur, const void *own, const void *base) {
+    if (NULL != cur && base != cur) {
+        OJ_R_FREE((void *)cur);
+    }
+    if (NULL != own && base != own && cur != own) {
+        OJ_R_FREE((void *)own);
+    }
+}
 
-    return rstr;
+static VALUE write_call_ensure(VALUE a) {
+    struct write_call_arg *arg   = (struct write_call_arg *)a;
+    Options                copts = arg->copts;
+    struct option_buffers  none  = {NULL, NULL, NULL, NULL};
+    struct option_buffers *base  = arg->owned ? &none : &arg->base;
+
+    free_call_buffer(copts->create_id, arg->own.create_id, base->create_id);
+    free_call_buffer(copts->ignore, arg->own.ignore, base->ignore);
+    free_call_buffer(copts->dump_opts.only, arg->own.only, base->only);
+    free_call_buffer(copts->dump_opts.except, arg->own.except, base->except);
+
+    return Qnil;
+}
+
+static VALUE to_file_body(VALUE a) {
+    struct write_call_arg *arg = (struct write_call_arg *)a;
+
+    write_call_options(arg);
+    oj_write_obj_to_file(arg->argv[1], StringValueCStr(*arg->argv), arg->copts);
+
+    return Qnil;
 }
 
 /* Document-method: to_file
@@ -1841,13 +1895,21 @@ static VALUE to_json(int argc, VALUE *argv, VALUE self) {
  *   - *:circular* [_Boolean_] allow circular references, default: false
  */
 static VALUE to_file(int argc, VALUE *argv, VALUE self) {
-    struct _options copts = oj_default_options;
+    struct _options       copts;
+    struct write_call_arg arg = {&copts, argc, argv};
 
-    if (3 == argc) {
-        oj_parse_options(argv[2], &copts);
-    }
-    oj_write_obj_to_file(argv[1], StringValuePtr(*argv), &copts);
-    oj_free_call_options(&copts);
+    StringValueCStr(*argv);
+    copts = oj_default_options;
+    option_buffers_get(&copts, &arg.base);
+
+    return rb_ensure(to_file_body, (VALUE)&arg, write_call_ensure, (VALUE)&arg);
+}
+
+static VALUE to_stream_body(VALUE a) {
+    struct write_call_arg *arg = (struct write_call_arg *)a;
+
+    write_call_options(arg);
+    oj_write_obj_to_stream(arg->argv[1], *arg->argv, arg->copts);
 
     return Qnil;
 }
@@ -1863,15 +1925,12 @@ static VALUE to_file(int argc, VALUE *argv, VALUE self) {
  *   - *:circular* [_Boolean_] allow circular references, default: false
  */
 static VALUE to_stream(int argc, VALUE *argv, VALUE self) {
-    struct _options copts = oj_default_options;
+    struct _options       copts = oj_default_options;
+    struct write_call_arg arg   = {&copts, argc, argv};
 
-    if (3 == argc) {
-        oj_parse_options(argv[2], &copts);
-    }
-    oj_write_obj_to_stream(argv[1], *argv, &copts);
-    oj_free_call_options(&copts);
+    option_buffers_get(&copts, &arg.base);
 
-    return Qnil;
+    return rb_ensure(to_stream_body, (VALUE)&arg, write_call_ensure, (VALUE)&arg);
 }
 
 /* Document-method: register_odd

data/ext/oj/oj.h

@@ -266,6 +266,7 @@ extern void  oj_options_mark(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 VALUE oj_dump_obj_to_str(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);

data/ext/oj/parse.c

@@ -390,6 +390,32 @@ void oj_scanner_init(void) {
     }
 }
 
+// JSON does not allow an unescaped control character (below 0x20) in a
+// string. Like a trailing decimal point, that is only rejected in strict mode
+// and when mimicking the JSON gem.
+static inline bool reject_control_chars(ParseInfo pi) {
+    return StrictMode == pi->options.mode || CompatMode == pi->options.mode;
+}
+
+static const char *find_control_char(const char *s, const char *end) {
+    // Eight bytes at a time first: a byte below 0x20 sets its high bit in
+    // (w - 0x20...) & ~w.
+    for (; s + sizeof(uint64_t) <= end; s += sizeof(uint64_t)) {
+        uint64_t w;
+
+        memcpy(&w, s, sizeof(w));
+        if (0 != ((w - 0x2020202020202020ULL) & ~w & 0x8080808080808080ULL)) {
+            break;
+        }
+    }
+    for (; s < end; s++) {
+        if ((unsigned char)*s < 0x20) {
+            return s;
+        }
+    }
+    return NULL;
+}
+
 // entered at /
 static void read_escaped_str(ParseInfo pi, const char *start) {
     struct _buf buf;
@@ -409,6 +435,16 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
             buf_cleanup(&buf);
             return;
         }
+        if (reject_control_chars(pi)) {
+            const char *ctrl = find_control_char(s, scanned);
+
+            if (NULL != ctrl) {
+                pi->cur = ctrl;
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+                buf_cleanup(&buf);
+                return;
+            }
+        }
         buf_append_string(&buf, s, (size_t)(scanned - s));
         s = scanned;
 
@@ -543,6 +579,15 @@ static void read_str(ParseInfo pi) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "NULL byte in string");
         return;
     }
+    if (reject_control_chars(pi)) {
+        const char *ctrl = find_control_char(str, pi->cur);
+
+        if (NULL != ctrl) {
+            pi->cur = ctrl;
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+            return;
+        }
+    }
     if ('\\' == *pi->cur) {
         read_escaped_str(pi, str);
         return;
@@ -1205,17 +1250,20 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
         }
     } else {
         VALUE clas = rb_obj_class(input);
-        VALUE s;
 
         if (oj_stringio_class == clas) {
-            s = rb_funcall2(input, oj_string_id, 0, 0);
-            oj_pi_set_input_str(pi, &s);
+            input = rb_funcall2(input, oj_string_id, 0, 0);
+            StringValue(input);
+            oj_pi_set_input_str(pi, &input);
 #if !IS_WINDOWS
         } else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
             int     fd = FIX2INT(rb_funcall(input, oj_fileno_id, 0));
             ssize_t cnt;
             size_t  len = lseek(fd, 0, SEEK_END);
 
+            if ((size_t)-1 == len) {
+                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            }
             lseek(fd, 0, SEEK_SET);
             buf      = OJ_R_ALLOC_N(char, len + 1);
             pi->json = buf;
@@ -1342,6 +1390,7 @@ CLEANUP:
             if (NULL != pi->json) {
                 msg = rb_str_append(msg, rb_utf8_str_new_cstr(" in '"));
                 msg = rb_str_append(msg, rb_utf8_str_new_cstr(pi->json));
+                RB_GC_GUARD(input);
             }
             args[0] = msg;
             if (pi->err.clas == oj_parse_error_class) {
@@ -1381,5 +1430,6 @@ CLEANUP:
             break;
         }
     }
+    RB_GC_GUARD(input);
     return result;
 }

data/ext/oj/parse.h

@@ -81,6 +81,7 @@ extern VALUE oj_num_as_value(NumInfo ni);
 extern void oj_set_strict_callbacks(ParseInfo pi);
 extern void oj_set_object_callbacks(ParseInfo pi);
 extern void oj_set_compat_callbacks(ParseInfo pi);
+extern void oj_compat_array_append_other(VALUE a, VALUE value);
 extern void oj_set_custom_callbacks(ParseInfo pi);
 extern void oj_set_wab_callbacks(ParseInfo pi);
 
@@ -108,6 +109,14 @@ static inline void parse_info_init(ParseInfo pi) {
 
 extern void oj_scanner_init(void);
 
+static inline void oj_compat_array_append(VALUE a, VALUE value) {
+    if (rb_cArray == RBASIC_CLASS(a)) {
+        rb_ary_push(a, value);
+    } else {
+        oj_compat_array_append_other(a, value);
+    }
+}
+
 static inline bool empty_ok(Options options) {
     switch (options->mode) {
     case ObjectMode:

data/ext/oj/parser.c

@@ -179,8 +179,8 @@ static const char neg_map[258] = "\
 static const char zero_map[258] = "\
 .........rs..r..................\
 r...........u.t.................\
-.............................H..\
-.............................G..\
+.....w.......................H..\
+.....w.......................G..\
 ................................\
 ................................\
 ................................\
@@ -762,6 +762,12 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
             calc_num(p);
             // flow through
         case CLOSE_OBJECT:
+            // Inside an object value_map is only in use right after a colon.
+            if (value_map == p->map && 0 < p->depth && OBJECT_FUN == p->stack[p->depth]) {
+                p->col = b - json - p->col + 1;
+                parse_error(p, "expected a value, not an object close");
+                return;
+            }
             p->map = (1 == p->depth) ? value_map : after_map;
             if (p->depth <= 0 || OBJECT_FUN != p->stack[p->depth]) {
                 p->col = b - json - p->col + 1;
@@ -881,6 +887,11 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
                     p->num.shift++;
                 } else {
                     big_change(p);
+                    if (0 == p->num.shift) {
+                        // No fraction digit was read yet so big_change()
+                        // did not add the '.' before the digits that follow.
+                        buf_append(&p->buf, '.');
+                    }
                     p->map = big_frac_map;
                     break;
                 }
@@ -893,6 +904,7 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
             break;
         case NUM_ZERO: p->map = zero_map; break;
         case NEG_DIGIT:
+            p->map = digit_map;
             for (; NUM_DIGIT == digit_map[*b]; b++) {
                 uint64_t x = p->num.fixnum * 10 + (uint64_t)(*b - '0');
 
@@ -905,7 +917,6 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
                 }
             }
             b--;
-            p->map = digit_map;
             break;
         case EXP_SIGN:
             p->num.exp_neg = ('-' == *b);
@@ -964,10 +975,12 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
         case NUM_SPC:
             p->cur = b - json;
             calc_num(p);
+            p->map = (0 == p->depth) ? value_map : after_map;
             break;
         case NUM_NEWLINE:
             p->cur = b - json;
             calc_num(p);
+            p->map = (0 == p->depth) ? value_map : after_map;
             b++;
 #ifdef SPACE_JUMP
             // for (uint32_t *sj = (uint32_t*)b; 0x20202020 == *sj; sj++) { b += 4; }
@@ -1010,15 +1023,26 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
             p->ri++;
             p->ucode = p->ucode << 4 | (uint32_t)hex_map[*b];
             if (4 <= p->ri) {
-                byte   utf8[8];
-                size_t ulen = unicodeToUtf8(p->ucode, utf8);
+                byte     utf8[8];
+                Buf      buf  = (':' == p->next_map[256]) ? &p->key : &p->buf;
+                uint32_t code = p->ucode;
 
-                if (0 < ulen) {
-                    if (':' == p->next_map[256]) {
-                        buf_append_string(&p->key, (const char *)utf8, ulen);
-                    } else {
-                        buf_append_string(&p->buf, (const char *)utf8, ulen);
+                // A low surrogate right after a high one, which the previous
+                // escape appended on its own, completes a pair.
+                if (0xDC00 <= code && code <= 0xDFFF && 3 <= buf_len(buf)) {
+                    const byte *hi = (const byte *)buf->tail - 3;
+
+                    if (0xED == hi[0] && 0xA0 <= hi[1] && hi[1] <= 0xAF) {
+                        uint32_t c1 = ((uint32_t)(hi[1] & 0x0F) << 6) | (hi[2] & 0x3F);
+
+                        code = ((c1 << 10) | (code - 0xDC00)) + 0x00010000;
+                        buf->tail -= 3;
                     }
+                }
+                size_t ulen = unicodeToUtf8(code, utf8);
+
+                if (0 < ulen) {
+                    buf_append_string(buf, (const char *)utf8, ulen);
                 } else {
                     parse_error(p, "invalid unicode");
                     return;
@@ -1208,11 +1232,9 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
         case '0':
         case 'd':
         case 'f':
-        case 'z':
         case 'X':
         case 'D':
         case 'g':
-        case 'B':
         case 'Y':
             p->cur = b - json;
             calc_num(p);
@@ -1462,6 +1484,23 @@ static void validate_primitives_are_complete(ojParser p) {
     }
 }
 
+// A top level number that stops after a '-', a '.', an 'e' or an exponent
+// sign is still waiting for a digit.
+static void validate_number_is_complete(ojParser p) {
+    if (0 < p->depth) {
+        return;
+    }
+    switch (p->map[256]) {
+    case '-':
+    case '.':
+    case 'x':
+    case 'z':
+    case 'o':
+    case 'B':
+    case 'Z': parse_error(p, "incomplete number"); break;
+    }
+}
+
 static void validate_non_primitives_are_complete(ojParser p) {
     if (0 >= p->depth) {
         return;
@@ -1475,6 +1514,7 @@ static void validate_non_primitives_are_complete(ojParser p) {
 
 static void validate_document_end(ojParser p) {
     validate_primitives_are_complete(p);
+    validate_number_is_complete(p);
     validate_non_primitives_are_complete(p);
 }
 
@@ -1487,19 +1527,20 @@ static void validate_document_end(ojParser p) {
  */
 static VALUE parser_parse(VALUE self, VALUE json) {
     ojParser    p;
-    int         frozen = OBJ_FROZEN(json);
     const byte *ptr;
 
-    if (!frozen) {
+    StringValue(json);
+    if (!OBJ_FROZEN(json)) {
         rb_str_freeze(json);
     }
-    ptr = (const byte *)StringValuePtr(json);
+    ptr = (const byte *)RSTRING_PTR(json);
 
     TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     parser_reset(p);
     p->start(p);
     parse(p, ptr, (size_t)RSTRING_LEN(json), false);
+    RB_GC_GUARD(json);
     validate_document_end(p);
 
     return p->result(p);
@@ -1599,7 +1640,7 @@ static VALUE parser_file(VALUE self, VALUE filename) {
 
     TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
-    path = StringValuePtr(filename);
+    path = StringValueCStr(filename);
 
     parser_reset(p);
     p->start(p);

data/ext/oj/rails.c

@@ -1062,6 +1062,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     }
     if (Yes == copts.circular) {
         oj_cache8_delete(out.circ_cache);
+        out.circ_cache = NULL;
     }
 
     oj_out_free(&out);
@@ -1316,12 +1317,15 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     size_t cnt = 0;
 
     if (0.0 == d) {
-        b    = buf;
+        b = buf;
+        if (signbit(d)) {
+            *b++ = '-';
+        }
         *b++ = '0';
         *b++ = '.';
         *b++ = '0';
-        *b++ = '\0';
-        cnt  = 3;
+        *b   = '\0';
+        cnt  = b - buf;
     } else {
         if (isnan(d) || OJ_INFINITY == d || -OJ_INFINITY == d) {
             strcpy(buf, "null");
@@ -1372,6 +1376,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         cnt--;
         for (i = 0; i <= cnt; i++) {
             if (out->opts->dump_opts.use) {
+                assure_size(out, size);
                 if (0 < out->opts->dump_opts.array_size) {
                     APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }

data/ext/oj/reader.c

@@ -45,6 +45,7 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
     reader->line            = 1;
     reader->col             = 0;
     reader->free_head       = 0;
+    reader->in_val          = Qnil;
 
     if (0 != fd) {
         reader->read_func = read_from_fd;
@@ -52,6 +53,7 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
     } else if (rb_cString == io_class) {
         reader->read_func = 0;
         reader->in_str    = StringValuePtr(io);
+        reader->in_val    = io;
         reader->head      = (char *)reader->in_str;
         reader->tail      = reader->head;
         reader->read_end  = reader->head + RSTRING_LEN(io);
@@ -60,6 +62,7 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
 
         reader->read_func = 0;
         reader->in_str    = StringValuePtr(s);
+        reader->in_val    = s;
         reader->head      = (char *)reader->in_str;
         reader->tail      = reader->head;
         reader->read_end  = reader->head + RSTRING_LEN(s);
@@ -79,6 +82,7 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
 
         reader->read_func = 0;
         reader->in_str    = StringValuePtr(rstr);
+        reader->in_val    = rstr;
         reader->head      = (char *)reader->in_str;
         reader->tail      = reader->head;
         reader->read_end  = reader->head + RSTRING_LEN(rstr);

data/ext/oj/reader.h

@@ -24,6 +24,7 @@ typedef struct _reader {
         VALUE       io;
         const char *in_str;
     };
+    VALUE in_val;
 } *Reader;
 
 extern void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s);

data/ext/oj/resolve.c

@@ -82,8 +82,9 @@ oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE
 
 VALUE
 oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class) {
-    size_t      len = RSTRING_LEN(nameVal);
-    const char *str = StringValuePtr(nameVal);
-
-    return resolve_classpath(pi, str, len, 0, error_class);
+    if (T_STRING != rb_type(nameVal)) {
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "Invalid struct data");
+        return Qundef;
+    }
+    return resolve_classpath(pi, RSTRING_PTR(nameVal), RSTRING_LEN(nameVal), 0, error_class);
 }