oj 2.18.3 → 3.13.14

data/ext/oj/saj2.c

@@ -0,0 +1,348 @@
+// Copyright (c) 2021, Peter Ohler, All rights reserved.
+
+#include "cache.h"
+#include "oj.h"
+#include "parser.h"
+
+typedef struct _delegate {
+    VALUE          handler;
+    VALUE *        keys;
+    VALUE *        tail;
+    size_t         klen;
+    struct _cache *str_cache;
+    uint8_t        cache_str;
+    bool           cache_keys;
+    bool           thread_safe;
+} * Delegate;
+
+static VALUE get_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    const char *   key = buf_str(&p->key);
+    size_t         len = buf_len(&p->key);
+    volatile VALUE rkey;
+
+    if (d->cache_keys) {
+        rkey = cache_intern(d->str_cache, key, len);
+    } else {
+        rkey = rb_utf8_str_new(key, len);
+    }
+    return rkey;
+}
+
+static void push_key(Delegate d, VALUE key) {
+    if (d->klen <= (size_t)(d->tail - d->keys)) {
+        size_t off = d->tail - d->keys;
+
+        d->klen += d->klen / 2;
+        REALLOC_N(d->keys, VALUE, d->klen);
+        d->tail = d->keys + off;
+    }
+    *d->tail = key;
+    d->tail++;
+}
+
+static void noop(ojParser p) {
+}
+
+static void open_object(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_hash_start_id, 1, Qnil);
+}
+
+static void open_object_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_hash_start_id, 1, key);
+}
+
+static void open_array(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_array_start_id, 1, Qnil);
+}
+
+static void open_array_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_array_start_id, 1, key);
+}
+
+static void close_object(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_hash_end_id, 1, key);
+}
+
+static void close_array(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_array_end_id, 1, key);
+}
+
+static void add_null(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, Qnil);
+}
+
+static void add_null_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, get_key(p));
+}
+
+static void add_true(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, Qnil);
+}
+
+static void add_true_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, get_key(p));
+}
+
+static void add_false(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, Qnil);
+}
+
+static void add_false_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, get_key(p));
+}
+
+static void add_int(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), Qnil);
+}
+
+static void add_int_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), get_key(p));
+}
+
+static void add_float(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), Qnil);
+}
+
+static void add_float_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), get_key(p));
+}
+
+static void add_big(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               2,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               Qnil);
+}
+
+static void add_big_key(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               2,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               get_key(p));
+}
+
+static void add_str(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char *   str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str < len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 2, rstr, Qnil);
+}
+
+static void add_str_key(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char *   str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str < len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 2, rstr, get_key(p));
+}
+
+static void reset(ojParser p) {
+    Funcs end = p->funcs + 3;
+    Funcs f;
+
+    for (f = p->funcs; f < end; f++) {
+        f->add_null     = noop;
+        f->add_true     = noop;
+        f->add_false    = noop;
+        f->add_int      = noop;
+        f->add_float    = noop;
+        f->add_big      = noop;
+        f->add_str      = noop;
+        f->open_array   = noop;
+        f->close_array  = noop;
+        f->open_object  = noop;
+        f->close_object = noop;
+    }
+}
+
+static VALUE option(ojParser p, const char *key, VALUE value) {
+    Delegate d = (Delegate)p->ctx;
+
+    if (0 == strcmp(key, "handler")) {
+        return d->handler;
+    }
+    if (0 == strcmp(key, "handler=")) {
+        d->tail    = d->keys;
+        d->handler = value;
+        reset(p);
+        if (rb_respond_to(value, oj_hash_start_id)) {
+            p->funcs[TOP_FUN].open_object    = open_object;
+            p->funcs[ARRAY_FUN].open_object  = open_object;
+            p->funcs[OBJECT_FUN].open_object = open_object_key;
+        }
+        if (rb_respond_to(value, oj_array_start_id)) {
+            p->funcs[TOP_FUN].open_array    = open_array;
+            p->funcs[ARRAY_FUN].open_array  = open_array;
+            p->funcs[OBJECT_FUN].open_array = open_array_key;
+        }
+        if (rb_respond_to(value, oj_hash_end_id)) {
+            p->funcs[TOP_FUN].close_object    = close_object;
+            p->funcs[ARRAY_FUN].close_object  = close_object;
+            p->funcs[OBJECT_FUN].close_object = close_object;
+        }
+        if (rb_respond_to(value, oj_array_end_id)) {
+            p->funcs[TOP_FUN].close_array    = close_array;
+            p->funcs[ARRAY_FUN].close_array  = close_array;
+            p->funcs[OBJECT_FUN].close_array = close_array;
+        }
+        if (rb_respond_to(value, oj_add_value_id)) {
+            p->funcs[TOP_FUN].add_null    = add_null;
+            p->funcs[ARRAY_FUN].add_null  = add_null;
+            p->funcs[OBJECT_FUN].add_null = add_null_key;
+
+            p->funcs[TOP_FUN].add_true    = add_true;
+            p->funcs[ARRAY_FUN].add_true  = add_true;
+            p->funcs[OBJECT_FUN].add_true = add_true_key;
+
+            p->funcs[TOP_FUN].add_false    = add_false;
+            p->funcs[ARRAY_FUN].add_false  = add_false;
+            p->funcs[OBJECT_FUN].add_false = add_false_key;
+
+            p->funcs[TOP_FUN].add_int    = add_int;
+            p->funcs[ARRAY_FUN].add_int  = add_int;
+            p->funcs[OBJECT_FUN].add_int = add_int_key;
+
+            p->funcs[TOP_FUN].add_float    = add_float;
+            p->funcs[ARRAY_FUN].add_float  = add_float;
+            p->funcs[OBJECT_FUN].add_float = add_float_key;
+
+            p->funcs[TOP_FUN].add_big    = add_big;
+            p->funcs[ARRAY_FUN].add_big  = add_big;
+            p->funcs[OBJECT_FUN].add_big = add_big_key;
+
+            p->funcs[TOP_FUN].add_str    = add_str;
+            p->funcs[ARRAY_FUN].add_str  = add_str;
+            p->funcs[OBJECT_FUN].add_str = add_str_key;
+        }
+        return Qnil;
+    }
+    if (0 == strcmp(key, "cache_keys")) {
+        return d->cache_keys ? Qtrue : Qfalse;
+    }
+    if (0 == strcmp(key, "cache_keys=")) {
+        d->cache_keys = (Qtrue == value);
+
+        return d->cache_keys ? Qtrue : Qfalse;
+    }
+    if (0 == strcmp(key, "cache_strings")) {
+        return INT2NUM((int)d->cache_str);
+    }
+    if (0 == strcmp(key, "cache_strings=")) {
+        int limit = NUM2INT(value);
+
+        if (CACHE_MAX_KEY < limit) {
+            limit = CACHE_MAX_KEY;
+        } else if (limit < 0) {
+            limit = 0;
+        }
+        d->cache_str = limit;
+
+        return INT2NUM((int)d->cache_str);
+    }
+    rb_raise(rb_eArgError, "%s is not an option for the SAJ (Simple API for JSON) delegate", key);
+
+    return Qnil;  // Never reached due to the raise but required by the compiler.
+}
+
+static VALUE result(ojParser p) {
+    return Qnil;
+}
+
+static void start(ojParser p) {
+    Delegate d = (Delegate)p->ctx;
+
+    d->tail = d->keys;
+}
+
+static void dfree(ojParser p) {
+    Delegate d = (Delegate)p->ctx;
+
+    if (NULL != d->keys) {
+        xfree(d->keys);
+    }
+    cache_free(d->str_cache);
+    xfree(p->ctx);
+}
+
+static void mark(ojParser p) {
+    if (NULL == p->ctx) {
+        return;
+    }
+    Delegate d = (Delegate)p->ctx;
+    VALUE *kp;
+
+    cache_mark(d->str_cache);
+    if (Qnil != d->handler) {
+        rb_gc_mark(d->handler);
+    }
+    if (!d->cache_keys) {
+        for (kp = d->keys; kp < d->tail; kp++) {
+            rb_gc_mark(*kp);
+        }
+    }
+}
+
+static VALUE form_str(const char *str, size_t len) {
+    return rb_str_freeze(rb_utf8_str_new(str, len));
+}
+
+void oj_set_parser_saj(ojParser p) {
+    Delegate d = ALLOC(struct _delegate);
+
+    d->klen      = 256;
+    d->keys      = ALLOC_N(VALUE, d->klen);
+    d->tail      = d->keys;
+    d->str_cache = cache_create(0, form_str, true, false);
+
+    p->ctx = (void *)d;
+    reset(p);
+    p->option = option;
+    p->result = result;
+    p->free   = dfree;
+    p->mark   = mark;
+    p->start  = start;
+}

data/ext/oj/scp.c

@@ -1,67 +1,35 @@
-/* scp.c
- * Copyright (c) 2012, 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.
- */
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <stdlib.h>
+#include <math.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <math.h>
 #include <sys/types.h>
 #include <unistd.h>
 
+#include "encode.h"
+#include "intern.h"
 #include "oj.h"
 #include "parse.h"
-#include "encode.h"
 
-static VALUE
-noop_start(ParseInfo pi) {
+static VALUE noop_start(ParseInfo pi) {
     return Qnil;
 }
 
-static void
-noop_end(ParseInfo pi) {
+static void noop_end(ParseInfo pi) {
 }
 
-static void
-noop_add_value(ParseInfo pi, VALUE val) {
+static void noop_add_value(ParseInfo pi, VALUE val) {
 }
 
-static void
-noop_add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+static void noop_add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
 }
 
-static void
-noop_add_num(ParseInfo pi, NumInfo ni) {
+static void noop_add_num(ParseInfo pi, NumInfo ni) {
 }
 
-static VALUE
-noop_hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
+static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
     return Qundef;
 }
 
@@ -69,178 +37,163 @@ static void
 noop_hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
 }
 
-static void
-noop_hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
+static void noop_hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
 }
 
-static void
-noop_hash_set_value(ParseInfo pi, Val kval, VALUE value) {
+static void noop_hash_set_value(ParseInfo pi, Val kval, VALUE value) {
 }
 
-static void
-noop_array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+static void noop_array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
 }
 
-static void
-noop_array_append_num(ParseInfo pi, NumInfo ni) {
+static void noop_array_append_num(ParseInfo pi, NumInfo ni) {
 }
 
-static void
-noop_array_append_value(ParseInfo pi, VALUE value) {
+static void noop_array_append_value(ParseInfo pi, VALUE value) {
 }
 
-static void
-add_value(ParseInfo pi, VALUE val) {
+static void add_value(ParseInfo pi, VALUE val) {
     rb_funcall(pi->handler, oj_add_value_id, 1, val);
 }
 
-static void
-add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
+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);
     rb_funcall(pi->handler, oj_add_value_id, 1, rstr);
 }
 
-static void
-add_num(ParseInfo pi, NumInfo ni) {
+static void add_num(ParseInfo pi, NumInfo ni) {
     rb_funcall(pi->handler, oj_add_value_id, 1, oj_num_as_value(ni));
 }
 
-static VALUE
-start_hash(ParseInfo pi) {
+static VALUE start_hash(ParseInfo pi) {
     return rb_funcall(pi->handler, oj_hash_start_id, 0);
 }
 
-static void
-end_hash(ParseInfo pi) {
+static void end_hash(ParseInfo pi) {
     rb_funcall(pi->handler, oj_hash_end_id, 0);
 }
 
-static VALUE
-start_array(ParseInfo pi) {
+static VALUE start_array(ParseInfo pi) {
     return rb_funcall(pi->handler, oj_array_start_id, 0);
 }
 
-static void
-end_array(ParseInfo pi) {
+static void end_array(ParseInfo pi) {
     rb_funcall(pi->handler, oj_array_end_id, 0);
 }
 
-static VALUE
-calc_hash_key(ParseInfo pi, Val kval) {
-    volatile VALUE	rkey = kval->key_val;
-
-    if (Qundef == rkey) {
-	rkey = rb_str_new(kval->key, kval->klen);
-	rkey = oj_encode(rkey);
-	if (Yes == pi->options.sym_key) {
-	    rkey = rb_str_intern(rkey);
-	}
-    }
-    return rkey;
-}
-
-static VALUE
-hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
+static VALUE hash_key(ParseInfo pi, const char *key, size_t klen) {
     return rb_funcall(pi->handler, oj_hash_key_id, 1, rb_str_new(key, klen));
 }
 
-static void
-hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
+static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
+    volatile VALUE rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), rstr);
+    rb_funcall(pi->handler,
+               oj_hash_set_id,
+               3,
+               stack_peek(&pi->stack)->val,
+               oj_calc_hash_key(pi, kval),
+               rstr);
 }
 
-static void
-hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), oj_num_as_value(ni));
+static void hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
+    rb_funcall(pi->handler,
+               oj_hash_set_id,
+               3,
+               stack_peek(&pi->stack)->val,
+               oj_calc_hash_key(pi, kval),
+               oj_num_as_value(ni));
 }
 
-static void
-hash_set_value(ParseInfo pi, Val kval, VALUE value) {
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), value);
+static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
+    rb_funcall(pi->handler,
+               oj_hash_set_id,
+               3,
+               stack_peek(&pi->stack)->val,
+               oj_calc_hash_key(pi, kval),
+               value);
 }
 
-static void
-array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
+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);
     rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, rstr);
 }
 
-static void
-array_append_num(ParseInfo pi, NumInfo ni) {
+static void array_append_num(ParseInfo pi, NumInfo ni) {
     rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, oj_num_as_value(ni));
 }
 
-static void
-array_append_value(ParseInfo pi, VALUE value) {
+static void array_append_value(ParseInfo pi, VALUE value) {
     rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, value);
 }
 
 VALUE
 oj_sc_parse(int argc, VALUE *argv, VALUE self) {
-    struct _ParseInfo	pi;
-    VALUE		input = argv[1];
+    struct _parseInfo pi;
+    VALUE             input = argv[1];
 
+    parse_info_init(&pi);
     pi.err_class = Qnil;
-    pi.options = oj_default_options;
+    pi.max_depth = 0;
+    pi.options   = oj_default_options;
     if (3 == argc) {
-	oj_parse_options(argv[2], &pi.options);
+        oj_parse_options(argv[2], &pi.options);
     }
     if (rb_block_given_p()) {
-	pi.proc = Qnil;
+        pi.proc = Qnil;
     } else {
-	pi.proc = Qundef;
+        pi.proc = Qundef;
     }
     pi.handler = *argv;
 
-    pi.start_hash = rb_respond_to(pi.handler, oj_hash_start_id) ? start_hash : noop_start;
-    pi.end_hash = rb_respond_to(pi.handler, oj_hash_end_id) ? end_hash : noop_end;
-    pi.hash_key = rb_respond_to(pi.handler, oj_hash_key_id) ? hash_key : noop_hash_key;
+    pi.start_hash  = rb_respond_to(pi.handler, oj_hash_start_id) ? start_hash : noop_start;
+    pi.end_hash    = rb_respond_to(pi.handler, oj_hash_end_id) ? end_hash : noop_end;
+    pi.hash_key    = rb_respond_to(pi.handler, oj_hash_key_id) ? hash_key : noop_hash_key;
     pi.start_array = rb_respond_to(pi.handler, oj_array_start_id) ? start_array : noop_start;
-    pi.end_array = rb_respond_to(pi.handler, oj_array_end_id) ? end_array : noop_end;
+    pi.end_array   = rb_respond_to(pi.handler, oj_array_end_id) ? end_array : noop_end;
     if (rb_respond_to(pi.handler, oj_hash_set_id)) {
-	pi.hash_set_value = hash_set_value;
-	pi.hash_set_cstr = hash_set_cstr;
-	pi.hash_set_num = hash_set_num;
-	pi.expect_value = 1;
+        pi.hash_set_value = hash_set_value;
+        pi.hash_set_cstr  = hash_set_cstr;
+        pi.hash_set_num   = hash_set_num;
+        pi.expect_value   = 1;
     } else {
-	pi.hash_set_value = noop_hash_set_value;
-	pi.hash_set_cstr = noop_hash_set_cstr;
-	pi.hash_set_num = noop_hash_set_num;
-	pi.expect_value = 0;
+        pi.hash_set_value = noop_hash_set_value;
+        pi.hash_set_cstr  = noop_hash_set_cstr;
+        pi.hash_set_num   = noop_hash_set_num;
+        pi.expect_value   = 0;
     }
     if (rb_respond_to(pi.handler, oj_array_append_id)) {
-	pi.array_append_value = array_append_value;
-	pi.array_append_cstr = array_append_cstr;
-	pi.array_append_num = array_append_num;
-	pi.expect_value = 1;
+        pi.array_append_value = array_append_value;
+        pi.array_append_cstr  = array_append_cstr;
+        pi.array_append_num   = array_append_num;
+        pi.expect_value       = 1;
     } else {
-	pi.array_append_value = noop_array_append_value;
-	pi.array_append_cstr = noop_array_append_cstr;
-	pi.array_append_num = noop_array_append_num;
-	pi.expect_value = 0;
+        pi.array_append_value = noop_array_append_value;
+        pi.array_append_cstr  = noop_array_append_cstr;
+        pi.array_append_num   = noop_array_append_num;
+        pi.expect_value       = 0;
     }
     if (rb_respond_to(pi.handler, oj_add_value_id)) {
-	pi.add_cstr = add_cstr;
-	pi.add_num = add_num;
-	pi.add_value = add_value;
-	pi.expect_value = 1;
+        pi.add_cstr     = add_cstr;
+        pi.add_num      = add_num;
+        pi.add_value    = add_value;
+        pi.expect_value = 1;
     } else {
-	pi.add_cstr = noop_add_cstr;
-	pi.add_num = noop_add_num;
-	pi.add_value = noop_add_value;
-	pi.expect_value = 0;
+        pi.add_cstr     = noop_add_cstr;
+        pi.add_num      = noop_add_num;
+        pi.add_value    = noop_add_value;
+        pi.expect_value = 0;
     }
+    pi.has_callbacks = true;
 
     if (T_STRING == rb_type(input)) {
-	return oj_pi_parse(argc - 1, argv + 1, &pi, 0, 0, 1);
+        return oj_pi_parse(argc - 1, argv + 1, &pi, 0, 0, 1);
     } else {
-	return oj_pi_sparse(argc - 1, argv + 1, &pi, 0);
+        return oj_pi_sparse(argc - 1, argv + 1, &pi, 0);
     }
 }