oj 2.0.0 → 3.0.0

data/ext/oj/buf.h

@@ -0,0 +1,103 @@
+/* buf.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __OJ_BUF_H__
+#define __OJ_BUF_H__
+
+#include "ruby.h"
+
+typedef struct _Buf {
+    char	*head;
+    char	*end;
+    char	*tail;
+    char	base[1024];
+} *Buf;
+
+inline static void
+buf_init(Buf buf) {
+    buf->head = buf->base;
+    buf->end = buf->base + sizeof(buf->base) - 1;
+    buf->tail = buf->head;
+}
+
+inline static void
+buf_cleanup(Buf buf) {
+    if (buf->base != buf->head) {
+        xfree(buf->head);
+    }
+}
+
+inline static size_t
+buf_len(Buf buf) {
+    return buf->tail - buf->head;
+}
+
+inline static void
+buf_append_string(Buf buf, const char *s, size_t slen) {
+    if (buf->end <= buf->tail + slen) {
+	size_t	len = buf->end - buf->head;
+	size_t	toff = buf->tail - buf->head;
+	size_t	new_len = len + slen + len / 2;
+
+	if (buf->base == buf->head) {
+	    buf->head = ALLOC_N(char, new_len);
+	    memcpy(buf->head, buf->base, len);
+	} else {
+	    REALLOC_N(buf->head, char, new_len);
+	}
+	buf->tail = buf->head + toff;
+	buf->end = buf->head + new_len - 1;
+    }
+    memcpy(buf->tail, s, slen);
+    buf->tail += slen;
+}
+    
+inline static void
+buf_append(Buf buf, char c) {
+    if (buf->end <= buf->tail) {
+	size_t	len = buf->end - buf->head;
+	size_t	toff = buf->tail - buf->head;
+	size_t	new_len = len + len / 2;
+
+	if (buf->base == buf->head) {
+	    buf->head = ALLOC_N(char, new_len);
+	    memcpy(buf->head, buf->base, len);
+	} else {
+	    REALLOC_N(buf->head, char, new_len);
+	}
+	buf->tail = buf->head + toff;
+	buf->end = buf->head + new_len - 1;
+    }
+    *buf->tail = c;
+    buf->tail++;
+    //*buf->tail = '\0'; // for debugging
+}
+
+#endif /* __OJ_BUF_H__ */

data/ext/oj/cache8.c

@@ -94,7 +94,11 @@ slot_print(Cache8 c, sid_t key, unsigned int depth) {
 	    k = (k8 << BITS) | i;
 	    /*printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i); */
 	    if (DEPTH - 1 == depth) {
+#if IS_WINDOWS
+		printf("0x%016lx: %4lu\n", (long unsigned int)k, (long unsigned int)b->value);
+#else
 		printf("0x%016llx: %4llu\n", (long long unsigned int)k, (long long unsigned int)b->value);
+#endif
 	    } else {
 		slot_print(b->child, k, depth + 1);
 	    }

data/ext/oj/circarray.c

@@ -0,0 +1,68 @@
+/* circarray.c
+ * Copyright (c) 2012, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "circarray.h"
+
+CircArray
+oj_circ_array_new() {
+    CircArray	ca;
+    
+    if (0 == (ca = ALLOC(struct _CircArray))) {
+	rb_raise(rb_eNoMemError, "not enough memory\n");
+    }
+    ca->objs = ca->obj_array;
+    ca->size = sizeof(ca->obj_array) / sizeof(VALUE);
+    ca->cnt = 0;
+    
+    return ca;
+}
+
+void
+oj_circ_array_free(CircArray ca) {
+    if (ca->objs != ca->obj_array) {
+	xfree(ca->objs);
+    }
+    xfree(ca);
+}
+
+void
+oj_circ_array_set(CircArray ca, VALUE obj, unsigned long id) {
+    if (0 < id && 0 != ca) {
+	unsigned long	i;
+
+	if (ca->size < id) {
+	    unsigned long	cnt = id + 512;
+
+	    if (ca->objs == ca->obj_array) {
+		if (0 == (ca->objs = ALLOC_N(VALUE, cnt))) {
+		    rb_raise(rb_eNoMemError, "not enough memory\n");
+		}
+		memcpy(ca->objs, ca->obj_array, sizeof(VALUE) * ca->cnt);
+	    } else { 
+		REALLOC_N(ca->objs, VALUE, cnt);
+	    }
+	    ca->size = cnt;
+	}
+	id--;
+	for (i = ca->cnt; i < id; i++) {
+	    ca->objs[i] = Qnil;
+	}
+	ca->objs[id] = obj;
+	if (ca->cnt <= id) {
+	    ca->cnt = id + 1;
+	}
+    }
+}
+
+VALUE
+oj_circ_array_get(CircArray ca, unsigned long id) {
+    VALUE	obj = Qnil;
+
+    if (id <= ca->cnt && 0 != ca) {
+	obj = ca->objs[id - 1];
+    }
+    return obj;
+}
+

data/ext/oj/circarray.h

@@ -0,0 +1,23 @@
+/* circarray.h
+ * Copyright (c) 2012, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OJ_CIRCARRAY_H__
+#define __OJ_CIRCARRAY_H__
+
+#include "ruby.h"
+
+typedef struct _CircArray {
+    VALUE		obj_array[1024];
+    VALUE		*objs;
+    unsigned long	size; // allocated size or initial array size
+    unsigned long	cnt;
+} *CircArray;
+
+extern CircArray	oj_circ_array_new(void);
+extern void		oj_circ_array_free(CircArray ca);
+extern void		oj_circ_array_set(CircArray ca, VALUE obj, unsigned long id);
+extern VALUE		oj_circ_array_get(CircArray ca, unsigned long id);
+
+#endif /* __OJ_CIRCARRAY_H__ */

data/ext/oj/code.c

@@ -0,0 +1,227 @@
+/* code.c
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "code.h"
+#include "dump.h"
+
+inline static VALUE
+resolve_classname(VALUE mod, const char *classname) {
+    VALUE	clas = Qundef;
+    ID		ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+	clas = rb_const_get_at(mod, ci);
+    }
+    return clas;
+}
+
+static VALUE
+path2class(const char *name) {
+    char	class_name[1024];
+    VALUE	clas;
+    char	*end = class_name + sizeof(class_name) - 1;
+    char	*s;
+    const char	*n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; '\0' != *n; n++) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    if (':' != *n) {
+		return Qundef;
+	    }
+	    if (Qundef == (clas = resolve_classname(clas, class_name))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qundef;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+
+    return resolve_classname(clas, class_name);
+}
+
+bool
+oj_code_dump(Code codes, VALUE obj, int depth, Out out) {
+    VALUE	clas = rb_obj_class(obj);
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas && c->active) {
+	    c->encode(obj, depth, out);
+	    return true;
+	}
+    }
+    return false;
+}
+
+VALUE
+oj_code_load(Code codes, VALUE clas, VALUE args) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas) {
+	    if (NULL == c->decode) {
+		break;
+	    }
+	    return c->decode(clas, args);
+	}
+    }
+    return Qnil;
+}
+
+void
+oj_code_set_active(Code codes, VALUE clas, bool active) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas || Qnil == clas) {
+	    c->active = active;
+	    if (Qnil != clas) {
+		break;
+	    }
+	}
+    }
+}
+
+bool
+oj_code_has(Code codes, VALUE clas, bool encode) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas) {
+	    if (encode) {
+		return c->active && NULL != c->encode;
+	    } else {
+		return c->active && NULL != c->decode;
+	    }
+	}
+    }
+    return false;
+}
+
+void
+oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out) {
+    int		d2 = depth + 1;
+    int		d3 = d2 + 1;
+    size_t	sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+    const char	*classname = rb_obj_classname(obj);
+    size_t	len = strlen(classname);
+    size_t	size = d2 * out->indent + 10 + len + out->opts->create_id_len + sep_len;
+
+    assure_size(out, size);
+    *out->cur++ = '{';
+    fill_indent(out, d2);
+    *out->cur++ = '"';
+    memcpy(out->cur, out->opts->create_id, out->opts->create_id_len);
+    out->cur += out->opts->create_id_len;
+    *out->cur++ = '"';
+    if (0 < out->opts->dump_opts.before_size) {
+	strcpy(out->cur, out->opts->dump_opts.before_sep);
+	out->cur += out->opts->dump_opts.before_size;
+    }
+    *out->cur++ = ':';
+    if (0 < out->opts->dump_opts.after_size) {
+	strcpy(out->cur, out->opts->dump_opts.after_sep);
+	out->cur += out->opts->dump_opts.after_size;
+    }
+    *out->cur++ = '"';
+    memcpy(out->cur, classname, len);
+    out->cur += len;
+    *out->cur++ = '"';
+
+    size = d3 * out->indent + 2;
+    for (; NULL != attrs->name; attrs++) {
+	assure_size(out, size + attrs->len + sep_len + 2);
+	*out->cur++ = ',';
+	fill_indent(out, d3);
+	*out->cur++ = '"';
+	memcpy(out->cur, attrs->name, attrs->len);
+	out->cur += attrs->len;
+	*out->cur++ = '"';
+	if (0 < out->opts->dump_opts.before_size) {
+	    strcpy(out->cur, out->opts->dump_opts.before_sep);
+	    out->cur += out->opts->dump_opts.before_size;
+	}
+	*out->cur++ = ':';
+	if (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
+	}
+	if (Qundef == attrs->value) {
+	    if (Qundef != attrs->time) {
+		switch (out->opts->time_format) {
+		case RubyTime:	oj_dump_ruby_time(attrs->time, out);	break;
+		case XmlTime:	oj_dump_xml_time(attrs->time, out);	break;
+		case UnixZTime:	oj_dump_time(attrs->time, out, true);	break;
+		case UnixTime:
+		default:	oj_dump_time(attrs->time, out, false);	break;
+		}
+	    } else {
+		char	buf[32];
+		char	*b = buf + sizeof(buf) - 1;
+		int	neg = 0;
+		long	num = attrs->num;
+	    
+		if (0 > num) {
+		    neg = 1;
+		    num = -num;
+		}
+		*b-- = '\0';
+		if (0 < num) {
+		    for (; 0 < num; num /= 10, b--) {
+			*b = (num % 10) + '0';
+		    }
+		    if (neg) {
+			*b = '-';
+		    } else {
+			b++;
+		    }
+		} else {
+		    *b = '0';
+		}
+		assure_size(out, (sizeof(buf) - (b - buf)));
+		for (; '\0' != *b; b++) {
+		    *out->cur++ = *b;
+		}
+	    }
+	} else {
+	    oj_dump_compat_val(attrs->value, d3, out, true);
+	}
+    }
+    assure_size(out, depth * out->indent + 2);
+    fill_indent(out, depth);
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}

data/ext/oj/code.h

@@ -0,0 +1,40 @@
+/* code.h
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OJ_CODE_H__
+#define __OJ_CODE_H__
+
+#include <ruby.h>
+
+#include "oj.h"
+
+typedef void	(*EncodeFunc)(VALUE obj, int depth, Out out);
+typedef VALUE	(*DecodeFunc)(VALUE clas, VALUE args);
+
+typedef struct _Code {
+    const char	*name;
+    VALUE	clas;
+    EncodeFunc	encode;
+    DecodeFunc	decode;
+    bool	active; // For compat mode.
+} *Code;
+
+// Used by encode functions.
+typedef struct _Attr {
+    const char	*name;
+    int		len;
+    VALUE	value;
+    long	num;
+    VALUE	time;
+} *Attr;
+
+extern bool	oj_code_dump(Code codes, VALUE obj, int depth, Out out);
+extern VALUE	oj_code_load(Code codes, VALUE clas, VALUE args);
+extern void	oj_code_set_active(Code codes, VALUE clas, bool active);
+extern bool	oj_code_has(Code codes, VALUE clas, bool encode);
+
+extern void	oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out);
+
+#endif /* __OJ_CODE_H__ */

data/ext/oj/compat.c

@@ -0,0 +1,243 @@
+/* compat.c
+ * Copyright (c) 2012, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <stdio.h>
+
+#include "oj.h"
+#include "err.h"
+#include "parse.h"
+#include "resolve.h"
+#include "hash.h"
+#include "encode.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;
+
+    if (Qundef == rkey &&
+	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 = rb_str_new(str, len);
+
+	if (Qundef == rkey) {
+	    rkey = rb_str_new(key, klen);
+	    rstr = oj_encode(rstr);
+	    rkey = oj_encode(rkey);
+	    if (Yes == pi->options.sym_key) {
+		rkey = rb_str_intern(rkey);
+	    }
+	}
+	if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+	    VALUE	clas = oj_rxclass_match(&pi->options.str_rx, str, len);
+
+	    if (Qnil != clas) {
+		rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
+	    }
+	}
+	if (rb_cHash != rb_obj_class(parent->val)) {
+	    // The rb_hash_set would still work but the unit tests for the
+	    // json gem require the less efficient []= method be called to set
+	    // values. Even using the store method to set the values will fail
+	    // the unit tests.
+	    rb_funcall(parent->val, rb_intern("[]="), 2, rkey, rstr);
+	} else {
+	    rb_hash_aset(parent->val, rkey, rstr);
+	}
+    }
+}
+
+static VALUE
+start_hash(ParseInfo pi) {
+    volatile VALUE	h;
+    
+    if (Qnil != pi->options.hash_class) {
+	h = rb_class_new_instance(0, NULL, pi->options.hash_class);
+    } else {
+	h = rb_hash_new();
+    }
+    return h;
+}
+
+static void
+end_hash(struct _ParseInfo *pi) {
+    Val	parent = stack_peek(&pi->stack);
+
+    if (0 != parent->classname) {
+	volatile VALUE	clas;
+
+	clas = oj_name2class(pi, parent->classname, parent->clen, 0, rb_eArgError);
+	if (Qundef != clas) { // else an error
+	    ID	creatable = rb_intern("json_creatable?");
+	    
+	    if (!rb_respond_to(clas, creatable) || Qtrue == rb_funcall(clas, creatable, 0)) {
+		parent->val = rb_funcall(clas, oj_json_create_id, 1, parent->val);
+	    }
+	}
+	if (0 != parent->classname) {
+	    xfree((char*)parent->classname);
+	    parent->classname = 0;
+	}
+    }
+}
+
+static VALUE
+calc_hash_key(ParseInfo pi, Val parent) {
+    volatile VALUE	rkey = parent->key_val;
+
+    if (Qundef == rkey) {
+	rkey = rb_str_new(parent->key, parent->klen);
+    }
+    rkey = oj_encode(rkey);
+    if (Yes == pi->options.sym_key) {
+	rkey = rb_str_intern(rkey);
+    }
+    return rkey;
+}
+
+static void
+add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    volatile VALUE	rstr = rb_str_new(str, len);
+
+    rstr = oj_encode(rstr);
+    if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+	VALUE	clas = oj_rxclass_match(&pi->options.str_rx, str, len);
+
+	if (Qnil != clas) {
+	    pi->stack.head->val = rb_funcall(clas, oj_json_create_id, 1, rstr);
+	    return;
+	}
+    }
+    pi->stack.head->val = rstr;
+}
+
+static void
+add_num(ParseInfo pi, NumInfo ni) {
+    pi->stack.head->val = oj_num_as_value(ni);
+}
+
+static void
+hash_set_num(struct _ParseInfo *pi, Val parent, NumInfo ni) {
+    if (!oj_use_hash_alt && rb_cHash != rb_obj_class(parent->val)) {
+	// The rb_hash_set would still work but the unit tests for the
+	// json gem require the less efficient []= method be called to set
+	// values. Even using the store method to set the values will fail
+	// the unit tests.
+	rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, calc_hash_key(pi, parent), oj_num_as_value(ni));
+    } else {
+	rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), oj_num_as_value(ni));
+    }
+}
+
+static void
+hash_set_value(ParseInfo pi, Val parent, VALUE value) {
+    if (rb_cHash != rb_obj_class(parent->val)) {
+	// The rb_hash_set would still work but the unit tests for the
+	// json gem require the less efficient []= method be called to set
+	// values. Even using the store method to set the values will fail
+	// the unit tests.
+	rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, calc_hash_key(pi, parent), value);
+    } else {
+	rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
+    }
+}
+
+static VALUE
+start_array(ParseInfo pi) {
+    if (Qnil != pi->options.array_class) {
+	return rb_class_new_instance(0, NULL, pi->options.array_class);
+    }
+    return rb_ary_new();
+}
+
+static void
+array_append_num(ParseInfo pi, NumInfo ni) {
+    Val	parent = stack_peek(&pi->stack);
+    
+    if (!oj_use_array_alt && rb_cArray != rb_obj_class(parent->val)) {
+	// The rb_ary_push would still work but the unit tests for the json
+	// gem require the less efficient << method be called to push the
+	// values.
+	rb_funcall(parent->val, rb_intern("<<"), 1, oj_num_as_value(ni));
+    } else {
+	rb_ary_push(parent->val, oj_num_as_value(ni));
+    }
+}
+
+static void
+array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    volatile VALUE	rstr = rb_str_new(str, len);
+
+    rstr = oj_encode(rstr);
+    if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+	VALUE	clas = oj_rxclass_match(&pi->options.str_rx, str, len);
+
+	if (Qnil != clas) {
+	    rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));
+	    return;
+	}
+    }
+    rb_ary_push(stack_peek(&pi->stack)->val, rstr);
+}
+
+void
+oj_set_compat_callbacks(ParseInfo pi) {
+    oj_set_strict_callbacks(pi);
+    pi->start_hash = start_hash;
+    pi->end_hash = end_hash;
+    pi->hash_set_cstr = hash_set_cstr;
+    pi->hash_set_num = hash_set_num;
+    pi->hash_set_value = hash_set_value;
+    pi->add_num = add_num;
+    pi->add_cstr = add_cstr;
+    pi->array_append_cstr = array_append_cstr;
+    pi->start_array = start_array;
+    pi->array_append_num = array_append_num;
+}
+
+VALUE
+oj_compat_parse(int argc, VALUE *argv, VALUE self) {
+    struct _ParseInfo	pi;
+
+    parse_info_init(&pi);
+    pi.options = oj_default_options;
+    pi.handler = Qnil;
+    pi.err_class = Qnil;
+    pi.max_depth = 0;
+    pi.options.allow_nan = Yes;
+    pi.options.nilnil = Yes;
+    oj_set_compat_callbacks(&pi);
+
+    if (T_STRING == rb_type(*argv)) {
+	return oj_pi_parse(argc, argv, &pi, 0, 0, false);
+    } else {
+	return oj_pi_sparse(argc, argv, &pi, 0);
+    }
+}
+
+VALUE
+oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
+    struct _ParseInfo	pi;
+
+    parse_info_init(&pi);
+    pi.options = oj_default_options;
+    pi.handler = Qnil;
+    pi.err_class = Qnil;
+    pi.max_depth = 0;
+    pi.options.allow_nan = Yes;
+    pi.options.nilnil = Yes;
+    oj_set_compat_callbacks(&pi);
+
+    return oj_pi_parse(argc, argv, &pi, json, len, false);
+}