oj 3.17.6 → 3.17.8

data/ext/oj/intern.c

@@ -17,9 +17,6 @@
 #define HASH_SLOT_CNT ((uint64_t)256)
 #define HASH_MASK (HASH_SLOT_CNT - 1)
 
-// almost the Murmur hash algorithm
-#define M 0x5bd1e995
-
 typedef struct _keyVal {
     struct _keyVal *next;
     const char     *key;
@@ -50,7 +47,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_to_symbol(rb_str_intern(rb_utf8_str_new(str, len)));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -150,40 +152,6 @@ ID oj_attr_intern(const char *key, size_t len) {
     return cache_intern(c, key, len);
 }
 
-static uint64_t hash_calc(const uint8_t *key, size_t len) {
-    const uint8_t *end     = key + len;
-    const uint8_t *endless = key + (len & 0xFFFFFFFC);
-    uint64_t       h       = (uint64_t)len ^ oj_hash_seed;
-    uint64_t       k;
-
-    while (key < endless) {
-        k = (uint64_t)*key++;
-        k |= (uint64_t)*key++ << 8;
-        k |= (uint64_t)*key++ << 16;
-        k |= (uint64_t)*key++ << 24;
-
-        k *= M;
-        k ^= k >> 24;
-        h *= M;
-        h ^= k * M;
-    }
-    if (1 < end - key) {
-        uint16_t k16 = (uint16_t)*key++;
-
-        k16 |= (uint16_t)*key++ << 8;
-        h ^= k16 << 8;
-    }
-    if (key < end) {
-        h ^= *key;
-    }
-    h *= M;
-    h ^= h >> 13;
-    h *= M;
-    h ^= h >> 15;
-
-    return h;
-}
-
 static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
     VALUE clas;
     ID    ci = rb_intern(classname);
@@ -243,61 +211,91 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     return clas;
 }
 
+typedef struct _internArgs {
+    KeyVal      bucket;  // last bucket in the chain for the key's slot
+    const char *key;
+    size_t      len;
+    ParseInfo   pi;
+    int         auto_define;
+    VALUE       error_class;
+} *InternArgs;
+
+// Resolves the class and only then adds it to the cache so a raise while
+// resolving does not leave a key cached with no value.
+static VALUE intern_new_class(VALUE a) {
+    InternArgs args   = (InternArgs)a;
+    KeyVal     bucket = args->bucket;
+    VALUE      clas   = resolve_classpath(args->pi, args->key, args->len, args->auto_define, args->error_class);
+
+    if (Qundef == clas) {
+        return clas;
+    }
+    if (NULL != bucket->key) {  // not the top slot
+        KeyVal b   = (KeyVal)OJ_R_ALLOC_N(char, sizeof(struct _keyVal) + args->len + 1);
+        char  *key = (char *)(b + 1);
+
+        memcpy(key, args->key, args->len);
+        key[args->len] = '\0';
+        b->next        = NULL;
+        b->key         = key;
+        bucket->next   = b;
+        bucket         = b;
+    } else {
+        bucket->key = oj_strndup(args->key, args->len);
+    }
+    bucket->len = args->len;
+    bucket->val = clas;
+
+    return clas;
+}
+
+static KeyVal find_class(KeyVal bucket, const char *key, size_t len, VALUE *clas) {
+    if (NULL != bucket->key) {  // not the top slot
+        for (KeyVal b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == memcmp(b->key, key, len)) {
+                *clas = b->val;
+                return NULL;
+            }
+            bucket = b;
+        }
+    }
+    return bucket;
+}
+
 VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int auto_define, VALUE error_class) {
-    uint64_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
-    KeyVal   bucket = class_hash.slots + h;
-    KeyVal   b;
+    uint64_t           h    = oj_hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    struct _internArgs args = {NULL, key, len, pi, auto_define, error_class};
+    VALUE              clas = Qundef;
 
     if (safe) {
+        int state = 0;
+
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&class_hash.mutex);
 #else
         rb_mutex_lock(class_hash.mutex);
 #endif
-        if (NULL != bucket->key) {  // not the top slot
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-#if HAVE_PTHREAD_MUTEX_INIT
-                    pthread_mutex_unlock(&class_hash.mutex);
-#else
-                    rb_mutex_unlock(class_hash.mutex);
-#endif
-                    return b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        // Resolving calls into Ruby and allocating, either of which can
+        // raise and unwind past the unlock, so the work is protected and any
+        // exception rethrown after the mutex is released.
+        if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+            clas = rb_protect(intern_new_class, (VALUE)&args, &state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_unlock(&class_hash.mutex);
 #else
         rb_mutex_unlock(class_hash.mutex);
 #endif
-    } else {
-        if (NULL != bucket->key) {
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-                    return (ID)b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        if (0 != state) {
+            rb_jump_tag(state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
+    } else if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+        clas = intern_new_class((VALUE)&args);
+    }
+    if (NULL != args.bucket && Qundef != clas) {  // newly added to the cache
+        rb_gc_register_mark_object(clas);
     }
-    rb_gc_register_mark_object(bucket->val);
-    return bucket->val;
+    return clas;
 }
 
 char *oj_strndup(const char *s, size_t len) {

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;
 }
 
@@ -461,7 +446,7 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
     } else {
-        h = argv[1];
+        h = rb_hash_dup(argv[1]);
     }
     if (!oj_hash_has_key(h, oj_indent_sym)) {
         rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));
@@ -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

@@ -1241,45 +1241,84 @@ static bool parse_one_option(VALUE k, VALUE v, Options copts) {
     return true;
 }
 
-// Collects the return of parse_one_option() over every key in a hash.
+// Collects the results of parse_one_option() over every key in a hash.
 struct _optsParse {
     Options copts;
-    bool    consumed;
+    bool    consumed;  // some key was an Oj option
+    VALUE   orig;      // the caller's hash, never modified
+    VALUE   rest;      // orig, or a copy of it without the Oj options
 };
 
+static void drop_from_rest(struct _optsParse *op, VALUE k) {
+    if (op->rest == op->orig) {
+        op->rest = rb_hash_dup(op->orig);
+    }
+    rb_hash_delete(op->rest, k);
+}
+
 static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
     struct _optsParse *op = (struct _optsParse *)opts;
 
     if (parse_one_option(k, v, op->copts)) {
         op->consumed = true;
+        // :only and :except are also read by ActiveSupport's as_json, which
+        // compat mode reaches through to_json, so they are left in.
+        if (only_sym != k && except_sym != k) {
+            drop_from_rest(op, k);
+        }
     }
     return ST_CONTINUE;
 }
 
-// Apply the options in ropts to copts and report whether any key was
-// recognized. A hash of nothing but unknown keys leaves copts untouched and
-// returns false.
-bool oj_parse_options_consumed(VALUE ropts, Options copts) {
-    struct _optsParse op = {copts, false};
+static void parse_options(VALUE ropts, Options copts, struct _optsParse *op) {
+    op->copts    = copts;
+    op->consumed = false;
+    op->orig     = ropts;
+    op->rest     = ropts;
 
     if (T_HASH != rb_type(ropts)) {
-        return false;
+        return;
     }
-    rb_hash_foreach(ropts, parse_options_cb, (VALUE)&op);
+    rb_hash_foreach(ropts, parse_options_cb, (VALUE)op);
     if (Qnil != rb_hash_lookup(ropts, match_string_sym)) {
-        op.consumed = true;
+        op->consumed = true;
+        drop_from_rest(op, match_string_sym);
     }
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size || 0 < copts->dump_opts.after_size ||
                             0 < copts->dump_opts.before_size || 0 < copts->dump_opts.hash_size ||
                             0 < copts->dump_opts.array_size);
+}
+
+// Apply the options in ropts to copts and report whether any key was
+// recognized. A hash of nothing but unknown keys leaves copts untouched and
+// returns false.
+bool oj_parse_options_consumed(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
 
     return op.consumed;
 }
 
+// Apply the options in ropts to copts and return what is left for the
+// to_json and as_json methods that Oj.dump() calls: ropts itself when it
+// holds no Oj option, otherwise a copy without them. The json gem's
+// generator raises on options it does not know as of json 3.0, so Oj's own
+// must not reach it. ropts is never modified.
+VALUE oj_parse_options_rest(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
+
+    return op.rest;
+}
+
 void oj_parse_options(VALUE ropts, Options copts) {
-    oj_parse_options_consumed(ropts, copts);
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
 }
 
 // Free the option buffers that oj_parse_options() allocated for a single call.
@@ -1550,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;
@@ -1703,6 +1742,7 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
     struct dump_arg arg;
     struct _out     out;
     struct _options copts = oj_default_options;
+    VALUE           to_json_argv[2];
 
     if (1 > argc) {
         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
@@ -1711,7 +1751,11 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
         copts.dump_opts.nan_dump = WordNan;
     }
     if (2 == argc) {
-        oj_parse_options(argv[1], &copts);
+        // The options hash is also what to_json and as_json receive, so
+        // hand them the hash without the options Oj itself acted on.
+        to_json_argv[0] = argv[0];
+        to_json_argv[1] = oj_parse_options_rest(argv[1], &copts);
+        argv            = to_json_argv;
     }
     if (CompatMode == copts.mode && copts.escape_mode != ASCIIEsc) {
         copts.escape_mode = JSONEsc;
@@ -1755,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).");
@@ -1774,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
@@ -1797,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;
 }
@@ -1819,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

@@ -255,16 +255,18 @@ extern VALUE oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 extern VALUE oj_object_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
 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 bool oj_parse_options_consumed(VALUE ropts, Options copts);
-extern void oj_free_call_options(Options copts);
-extern void oj_options_take_ownership(Options copts);
-extern void oj_options_release(Options copts);
-extern void oj_options_mark(Options copts);
+extern bool  oj_hash_has_key(VALUE hash, VALUE key);
+extern void  oj_parse_options(VALUE ropts, Options copts);
+extern bool  oj_parse_options_consumed(VALUE ropts, Options copts);
+extern VALUE oj_parse_options_rest(VALUE ropts, Options copts);
+extern void  oj_free_call_options(Options copts);
+extern void  oj_options_take_ownership(Options copts);
+extern void  oj_options_release(Options copts);
+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);