oj_windows 3.16.15

data/ext/oj_windows/cache8.c

@@ -0,0 +1,105 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "cache8.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "mem.h"
+#include "ruby.h"
+
+#define BITS 4
+#define MASK 0x000000000000000FULL
+#define SLOT_CNT 16
+#define DEPTH 16
+
+typedef union {
+    struct _cache8 *child;
+    slot_t          value;
+} Bucket;
+
+struct _cache8 {
+    Bucket buckets[SLOT_CNT];
+};
+
+static void cache8_delete(Cache8 cache, int depth);
+static void slot_print(Cache8 cache, sid_t key, unsigned int depth);
+
+void oj_cache8_new(Cache8 *cache) {
+    Bucket *b;
+    int     i;
+
+    *cache = OJ_R_ALLOC(struct _cache8);
+    for (i = SLOT_CNT, b = (*cache)->buckets; 0 < i; i--, b++) {
+        b->value = 0;
+    }
+}
+
+void oj_cache8_delete(Cache8 cache) {
+    cache8_delete(cache, 0);
+}
+
+static void cache8_delete(Cache8 cache, int depth) {
+    Bucket      *b;
+    unsigned int i;
+
+    for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
+        if (0 != b->child) {
+            if (DEPTH - 1 != depth) {
+                cache8_delete(b->child, depth + 1);
+            }
+        }
+    }
+    OJ_R_FREE(cache);
+}
+
+slot_t oj_cache8_get(Cache8 cache, sid_t key, slot_t **slot) {
+    Bucket *b;
+    int     i;
+    sid_t   k8 = (sid_t)key;
+    sid_t   k;
+
+    for (i = 64 - BITS; 0 < i; i -= BITS) {
+        k = (k8 >> i) & MASK;
+        b = cache->buckets + k;
+        if (0 == b->child) {
+            oj_cache8_new(&b->child);
+        }
+        cache = b->child;
+    }
+    *slot = &(cache->buckets + (k8 & MASK))->value;
+
+    return **slot;
+}
+
+void oj_cache8_print(Cache8 cache) {
+    /*printf("-------------------------------------------\n"); */
+    slot_print(cache, 0, 0);
+}
+
+static void slot_print(Cache8 c, sid_t key, unsigned int depth) {
+    Bucket      *b;
+    unsigned int i;
+    sid_t        k8 = (sid_t)key;
+    sid_t        k;
+
+    for (i = 0, b = c->buckets; i < SLOT_CNT; i++, b++) {
+        if (0 != b->child) {
+            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_windows/cache8.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_CACHE8_H
+#define OJ_CACHE8_H
+
+#include "ruby.h"
+#include "stdint.h"
+
+typedef struct _cache8 *Cache8;
+typedef uint64_t        slot_t;
+typedef uint64_t        sid_t;
+
+extern void oj_cache8_new(Cache8 *cache);
+extern void oj_cache8_delete(Cache8 cache);
+
+extern slot_t oj_cache8_get(Cache8 cache, sid_t key, slot_t **slot);
+
+extern void oj_cache8_print(Cache8 cache);
+
+#endif /* OJ_CACHE8_H */

data/ext/oj_windows/circarray.c

@@ -0,0 +1,64 @@
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "circarray.h"
+
+#include "mem.h"
+
+CircArray oj_circ_array_new(void) {
+    CircArray ca;
+
+    if (0 == (ca = OJ_R_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) {
+        OJ_R_FREE(ca->objs);
+    }
+    OJ_R_FREE(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 = OJ_R_ALLOC_N(VALUE, cnt))) {
+                    rb_raise(rb_eNoMemError, "not enough memory\n");
+                }
+                memcpy(ca->objs, ca->obj_array, sizeof(VALUE) * ca->cnt);
+            } else {
+                OJ_R_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_windows/circarray.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for
+// license details.
+
+#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_windows/code.c

@@ -0,0 +1,214 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#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, bool with_class) {
+    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;
+    bool        no_comma  = true;
+
+    assure_size(out, size);
+    *out->cur++ = '{';
+
+    if (with_class) {
+        fill_indent(out, d2);
+        *out->cur++ = '"';
+        APPEND_CHARS(out->cur, out->opts->create_id, out->opts->create_id_len);
+        *out->cur++ = '"';
+        if (0 < out->opts->dump_opts.before_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
+        }
+        *out->cur++ = ':';
+        if (0 < out->opts->dump_opts.after_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
+        }
+        *out->cur++ = '"';
+        APPEND_CHARS(out->cur, classname, len);
+        *out->cur++ = '"';
+        no_comma    = false;
+    }
+    size = d3 * out->indent + 2;
+    for (; NULL != attrs->name; attrs++) {
+        assure_size(out, size + attrs->len + sep_len + 2);
+        if (no_comma) {
+            no_comma = false;
+        } else {
+            *out->cur++ = ',';
+        }
+        fill_indent(out, d2);
+        *out->cur++ = '"';
+        APPEND_CHARS(out->cur, attrs->name, attrs->len);
+        *out->cur++ = '"';
+        if (0 < out->opts->dump_opts.before_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
+        }
+        *out->cur++ = ':';
+        if (0 < out->opts->dump_opts.after_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, 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;
+                bool   neg = false;
+                long   num = attrs->num;
+                size_t cnt = 0;
+
+                if (0 > num) {
+                    neg = true;
+                    num = -num;
+                }
+                *b-- = '\0';
+                if (0 < num) {
+                    b = oj_longlong_to_string(num, neg, b);
+                } else {
+                    *b = '0';
+                }
+                cnt = sizeof(buf) - (b - buf) - 1;
+                assure_size(out, cnt);
+                APPEND_CHARS(out->cur, b, cnt);
+            }
+        } 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_windows/code.h

@@ -0,0 +1,40 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#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, bool with_class);
+
+extern struct _code oj_compat_codes[];
+
+#endif /* OJ_CODE_H */

data/ext/oj_windows/compat.c

@@ -0,0 +1,239 @@
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include <stdio.h>
+
+#include "encode.h"
+#include "err.h"
+#include "intern.h"
+#include "mem.h"
+#include "oj.h"
+#include "parse.h"
+#include "resolve.h"
+#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);
+
+    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 (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)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);
+        }
+        TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, 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();
+    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
+    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) {
+            OJ_R_FREE((char *)parent->classname);
+            parent->classname = 0;
+        }
+    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
+}
+
+static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+
+    if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+
+        if (Qnil != clas) {
+            pi->stack.head->val = rb_funcall(clas, oj_json_create_id, 1, rstr);
+            return;
+        }
+    }
+    pi->stack.head->val = rstr;
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, rstr);
+}
+
+static void add_num(ParseInfo pi, NumInfo ni) {
+    pi->stack.head->val = oj_num_as_value(ni);
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, pi->stack.head->val);
+}
+
+static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
+    volatile VALUE rval = oj_num_as_value(ni);
+
+    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, oj_calc_hash_key(pi, parent), rval);
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rval);
+    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, rval);
+}
+
+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, oj_calc_hash_key(pi, parent), value);
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
+}
+
+static VALUE start_array(ParseInfo pi) {
+    if (Qnil != pi->options.array_class) {
+        return rb_class_new_instance(0, NULL, pi->options.array_class);
+    }
+    TRACE_PARSE_IN(pi->options.trace, "start_array", pi);
+    return rb_ary_new();
+}
+
+static void array_append_num(ParseInfo pi, NumInfo ni) {
+    Val            parent = stack_peek(&pi->stack);
+    volatile VALUE rval   = oj_num_as_value(ni);
+
+    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, rval);
+    } else {
+        rb_ary_push(parent->val, 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) {
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+
+    if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)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);
+    TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, 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;
+    pi.options.empty_string = No;
+    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_load(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;
+    pi.options.empty_string = 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);
+}