oj 3.17.6 → 3.17.8

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;
@@ -1261,7 +1309,11 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
     // value stack (while it is in scope).
     wrapped_stack = oj_stack_init(&pi->stack);
     rb_protect(protect_parse, (VALUE)pi, &line);
-    if (Qundef == pi->stack.head->val && !empty_ok(&pi->options)) {
+    // Only when nothing is on the stack was the input actually empty. A
+    // deferred hash (built at its closing brace from buffered pairs) leaves
+    // head->val Qundef while its entry is still on the stack, e.g. when a
+    // parse error cut the document short; the real error is already set.
+    if (Qundef == pi->stack.head->val && stack_empty(&pi->stack) && !empty_ok(&pi->options)) {
         if (No == pi->options.nilnil || (CompatMode == pi->options.mode && 0 < pi->cur - pi->json)) {
             oj_set_error_at(pi, oj_json_parser_error_class, __FILE__, __LINE__, "Empty input");
         }
@@ -1338,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) {
@@ -1377,5 +1430,6 @@ CLEANUP:
             break;
         }
     }
+    RB_GC_GUARD(input);
     return result;
 }

data/ext/oj/parse.h

@@ -5,6 +5,7 @@
 #define OJ_PARSE_H
 
 #include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -80,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);
 
@@ -90,11 +92,31 @@ extern VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str);
 extern VALUE oj_calc_hash_key(ParseInfo pi, Val parent);
 
 static inline void parse_info_init(ParseInfo pi) {
-    memset(pi, 0, sizeof(struct _parseInfo));
+    // Zeroing the whole struct costs more than parsing a small document: the
+    // embedded reader buffer (rd.base, 4KB) and value stack entries
+    // (stack.base, 6.5KB) dominate its 11KB. Both are fully initialized
+    // before use — oj_reader_init() for stream parses, oj_stack_init() and
+    // stack_push() for the value stack — so zero only the scalars around
+    // them.
+    memset(pi, 0, offsetof(struct _parseInfo, rd));
+    memset((char *)pi + offsetof(struct _parseInfo, rd) + offsetof(struct _reader, head),
+           0,
+           offsetof(struct _parseInfo, stack) - offsetof(struct _parseInfo, rd) - offsetof(struct _reader, head));
+    memset((char *)pi + offsetof(struct _parseInfo, stack) + offsetof(struct _valStack, head),
+           0,
+           sizeof(struct _parseInfo) - offsetof(struct _parseInfo, stack) - offsetof(struct _valStack, head));
 }
 
 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..\
 ................................\
 ................................\
 ................................\
@@ -509,20 +509,29 @@ static void calc_num(ojParser p) {
             d = -d;
         }
         if (0 < p->num.shift) {
-            d /= pow_map[p->num.shift];
-        }
-        if (0 < p->num.exp) {
-            long double x;
+            uint32_t shift = p->num.shift;
 
-            if (MAX_POW < p->num.exp) {
-                x = powl(10.0L, (long double)p->num.exp);
-            } else {
-                x = pow_map[p->num.exp];
+            while (MAX_POW < shift) {
+                d /= pow_map[MAX_POW];
+                shift -= MAX_POW;
             }
+            d /= pow_map[shift];
+        }
+        if (0 < p->num.exp) {
             if (p->num.exp_neg) {
-                d /= x;
+                int exp = p->num.exp;
+
+                while (MAX_POW < exp) {
+                    d /= pow_map[MAX_POW];
+                    exp -= MAX_POW;
+                }
+                d /= pow_map[exp];
             } else {
-                d *= x;
+                if (MAX_POW < p->num.exp) {
+                    d *= powl(10.0L, (long double)p->num.exp);
+                } else {
+                    d *= pow_map[p->num.exp];
+                }
             }
         }
         p->num.dub = d;
@@ -559,19 +568,31 @@ static void big_change(ojParser p) {
         break;
     case OJ_DECIMAL: {
         int shift = p->num.shift;
+        int end   = sizeof(buf) - 1;
 
-        for (len = sizeof(buf) - 1; 0 < i; len--, i /= 10, shift--) {
-            if (0 == shift) {
-                buf[len] = '.';
-                len--;
-            }
-            buf[len] = '0' + (i % 10);
-        }
+        len = end;
+        do {
+            buf[--len] = '0' + (i % 10);
+            i /= 10;
+        } while (0 < i);
         if (p->num.neg) {
-            buf[len] = '-';
-            len--;
+            buf_append(&p->buf, '-');
+        }
+        if (end - len <= shift) {
+            buf_append_string(&p->buf, "0.", 2);
+            for (int cnt = shift - (end - len); 0 < cnt; cnt--) {
+                buf_append(&p->buf, '0');
+            }
+            buf_append_string(&p->buf, buf + len, end - len);
+        } else {
+            int decimal = end - shift;
+
+            buf_append_string(&p->buf, buf + len, decimal - len);
+            if (0 < shift) {
+                buf_append(&p->buf, '.');
+                buf_append_string(&p->buf, buf + decimal, shift);
+            }
         }
-        buf_append_string(&p->buf, buf + len + 1, sizeof(buf) - len - 1);
         if (0 < p->num.exp) {
             int  x = p->num.exp;
             int  d, div;
@@ -585,6 +606,7 @@ static void big_change(ojParser p) {
                 d = x / div % 10;
                 if (started || 0 < d) {
                     buf_append(&p->buf, '0' + d);
+                    started = true;
                 }
             }
         }
@@ -740,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;
@@ -859,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;
                 }
@@ -871,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');
 
@@ -883,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);
@@ -942,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; }
@@ -988,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;
@@ -1186,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);
@@ -1440,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;
@@ -1453,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);
 }
 
@@ -1465,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);
@@ -1577,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/parser.h

@@ -34,7 +34,7 @@ typedef struct _num {
     uint32_t    len;
     int16_t     div;  // 10^div
     int16_t     exp;
-    uint8_t     shift;  // shift of fixnum to get decimal
+    uint32_t    shift;  // shift of fixnum to get decimal
     bool        neg;
     bool        exp_neg;
     // for numbers as strings, reuse buf

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);
 }

data/ext/oj/resolve.h

@@ -4,9 +4,18 @@
 #ifndef OJ_RESOLVE_H
 #define OJ_RESOLVE_H
 
+#include <stdbool.h>
+#include <string.h>
+
 #include "ruby.h"
 
 extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
 extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
 
+inline static bool oj_is_backtrace_name(const char *name, size_t len) {
+    static const char backtrace[] = "Thread::Backtrace";
+
+    return sizeof(backtrace) - 1 == len && 0 == memcmp(backtrace, name, len);
+}
+
 #endif /* OJ_RESOLVE_H */

data/ext/oj/saj.c

@@ -646,13 +646,14 @@ static VALUE protect_saj_parse(VALUE x) {
  */
 VALUE
 oj_saj_parse(int argc, VALUE *argv, VALUE self) {
-    char  *json  = 0;
-    size_t len   = 0;
-    VALUE  input = argv[1];
+    char  *json = 0;
+    size_t len  = 0;
+    VALUE  input;
 
     if (argc < 2) {
         rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
     }
+    input = argv[1];
     if (rb_type(input) == T_STRING) {
         // the json string gets modified so make a copy of it
         len  = RSTRING_LEN(input) + 1;
@@ -663,16 +664,20 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
         volatile VALUE s;
 
         if (oj_stringio_class == clas) {
-            s    = rb_funcall2(input, oj_string_id, 0, 0);
+            s = rb_funcall2(input, oj_string_id, 0, 0);
+            StringValueCStr(s);
             len  = RSTRING_LEN(s) + 1;
             json = OJ_R_ALLOC_N(char, len);
-            strcpy(json, StringValueCStr(s));
+            strcpy(json, RSTRING_PTR(s));
 #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;
 
             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);
             json = OJ_R_ALLOC_N(char, len + 1);
             {
@@ -681,6 +686,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
                 while (total < len) {
                     cnt = read(fd, json + total, len - total);
                     if (cnt <= 0) {
+                        OJ_R_FREE(json);
                         rb_raise(rb_eIOError, "failed to read from IO Object.");
                     }
                     total += cnt;
@@ -689,10 +695,11 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             json[len] = '\0';
 #endif
         } else if (rb_respond_to(input, oj_read_id)) {
-            s    = rb_funcall2(input, oj_read_id, 0, 0);
+            s = rb_funcall2(input, oj_read_id, 0, 0);
+            StringValueCStr(s);
             len  = RSTRING_LEN(s) + 1;
             json = OJ_R_ALLOC_N(char, len);
-            strcpy(json, StringValueCStr(s));
+            strcpy(json, RSTRING_PTR(s));
         } else {
             rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
         }