oj 2.0.14 → 2.1.0

data/ext/oj/parse.h

@@ -0,0 +1,88 @@
+/* parse.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_PARSE_H__
+#define __OJ_PARSE_H__
+
+#include <stdarg.h>
+
+#include "ruby.h"
+#include "oj.h"
+#include "val_stack.h"
+#include "circarray.h"
+
+typedef struct _NumInfo {
+    int64_t	i;
+    int64_t	num;
+    int64_t	div;
+    const char	*str;
+    size_t	len;
+    long	exp;
+    int		dec_cnt;
+    int		big;
+    int		infinity;
+    int		neg;
+} *NumInfo;
+
+typedef struct _ParseInfo {
+    const char		*json;
+    const char		*cur;
+    struct _Err		err;
+    struct _Options	options;
+    void		*cbc;
+    struct _ValStack	stack;
+    CircArray		circ_array;
+    int			expect_value;
+    VALUE		(*start_hash)(struct _ParseInfo *pi);
+    void		(*end_hash)(struct _ParseInfo *pi);
+    void		(*hash_set_cstr)(struct _ParseInfo *pi, const char *key, size_t klen, const char *str, size_t len, const char *orig);
+    void		(*hash_set_num)(struct _ParseInfo *pi, const char *key, size_t klen, NumInfo ni);
+    void		(*hash_set_value)(struct _ParseInfo *pi, const char *key, size_t klen, VALUE value);
+
+    VALUE		(*start_array)(struct _ParseInfo *pi);
+    void		(*end_array)(struct _ParseInfo *pi);
+    void		(*array_append_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*array_append_num)(struct _ParseInfo *pi, NumInfo ni);
+    void		(*array_append_value)(struct _ParseInfo *pi, VALUE value);
+
+    void		(*add_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*add_num)(struct _ParseInfo *pi, NumInfo ni);
+    void		(*add_value)(struct _ParseInfo *pi, VALUE val);
+} *ParseInfo;
+
+extern void	oj_parse2(ParseInfo pi);
+extern void	oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const char *format, ...);
+extern VALUE	oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json);
+extern VALUE	oj_num_as_value(NumInfo ni);
+
+extern void	oj_set_strict_callbacks(ParseInfo pi);
+extern void	oj_set_compat_callbacks(ParseInfo pi);
+
+#endif /* __OJ_PARSE_H__ */

data/ext/oj/resolve.c

@@ -0,0 +1,117 @@
+/* resolve.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.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#if SAFE_CACHE
+#include <pthread.h>
+#endif
+
+#include "oj.h"
+#include "err.h"
+#include "parse.h"
+#include "hash.h"
+
+inline static VALUE
+resolve_classname(VALUE mod, const char *classname, int auto_define) {
+    VALUE	clas;
+    ID		ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+	clas = rb_const_get_at(mod, ci);
+    } else if (auto_define) {
+	clas = rb_define_class_under(mod, classname, oj_bag_class);
+    } else {
+	clas = Qundef;
+    }
+    return clas;
+}
+
+static VALUE
+resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define) {
+    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 < len; n++, len--) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    len--;
+	    if (':' != *n) {
+		return Qundef;
+	    }
+	    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qundef;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+	if (sizeof(class_name) - 1 < len) {
+	    len = sizeof(class_name) - 1;
+	}
+	memcpy(class_name, name, len);
+	class_name[len] = '\0';
+	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "class %s is not defined", class_name);
+    }
+    return clas;
+}
+
+VALUE
+oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define) {
+    VALUE	clas;
+    VALUE	*slot;
+
+    if (No == pi->options.class_cache) {
+	return resolve_classpath(pi, name, len, auto_define);
+    }
+#if SAFE_CACHE
+    pthread_mutex_lock(&oj_cache_mutex);
+#endif
+    if (Qnil == (clas = oj_class_hash_get(name, len, &slot))) {
+	if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define))) {
+	    *slot = clas;
+	}
+    }
+#if SAFE_CACHE
+    pthread_mutex_unlock(&oj_cache_mutex);
+#endif
+    return clas;
+}

data/ext/oj/resolve.h

@@ -0,0 +1,38 @@
+/* resolve.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_RESOLVE_H__
+#define __OJ_RESOLVE_H__
+
+#include "ruby.h"
+
+extern VALUE	oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define);
+
+#endif /* __OJ_RESOLVE_H__ */

data/ext/oj/saj.c

@@ -1,4 +1,4 @@
-/* saj.c
+/* sajkey.c
  * Copyright (c) 2012, Peter Ohler
  * All rights reserved.
  * 
@@ -35,6 +35,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 // Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
 #define OJ_INFINITY (1.0/0.0)
@@ -669,8 +671,8 @@ respond_to(VALUE obj, ID method) {
 #endif
 }
 
-void
-oj_saj_parse(VALUE handler, char *json) {
+static void
+sajkey_parse(VALUE handler, char *json) {
     VALUE		obj = Qnil;
     struct _ParseInfo	pi;
 
@@ -718,93 +720,63 @@ oj_saj_parse(VALUE handler, char *json) {
     }
 }
 
-
-#if 0
-static void
-cx_add(CX cx, VALUE obj, const char *key) {
-    if (0 == cx->cur) {
-	cx->cur = cx->stack;
-	*cx->cur = obj;
+/* call-seq: sajkey_parse(handler, io)
+ *
+ * Parses an IO stream or file containing an JSON document. Raises an exception
+ * if the JSON is malformed.
+ * @param [Oj::SajKey] handler SajKey (responds to Oj::SajKey methods) like handler
+ * @param [IO|String] io IO Object to read from
+ */
+VALUE
+oj_saj_parse(int argc, VALUE *argv, VALUE self) {
+    char	*json = 0;
+    size_t	len = 0;
+    VALUE	input = argv[1];
+
+    if (argc < 2) {
+	rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
+    }
+    if (rb_type(input) == T_STRING) {
+	// the json string gets modified so make a copy of it
+	len = RSTRING_LEN(input) + 1;
+	json = ALLOC_N(char, len);
+	strcpy(json, StringValuePtr(input));
     } else {
-	if (0 != key) {
-	    VALUE	ks = rb_str_new2(key);
-#if HAS_ENCODING_SUPPORT
-	    rb_enc_associate(ks, oj_utf8_encoding);
+	VALUE	clas = rb_obj_class(input);
+	VALUE	s;
+
+	if (oj_stringio_class == clas) {
+	    s = rb_funcall2(input, oj_string_id, 0, 0);
+	    len = RSTRING_LEN(s) + 1;
+	    json = ALLOC_N(char, len);
+	    strcpy(json, StringValuePtr(s));
+#ifndef JRUBY_RUBY
+#if !IS_WINDOWS
+	    // JRuby gets confused with what is the real fileno.
+	} else if (rb_respond_to(input, oj_fileno_id) && Qnil != (s = rb_funcall(input, oj_fileno_id, 0))) {
+	    int		fd = FIX2INT(s);
+	    ssize_t	cnt;
+
+	    len = lseek(fd, 0, SEEK_END);
+	    lseek(fd, 0, SEEK_SET);
+	    json = ALLOC_N(char, len + 1);
+	    if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
+		rb_raise(rb_eIOError, "failed to read from IO Object.");
+	    }
+	    json[len] = '\0';
+#endif
 #endif
-	    rb_hash_aset(*cx->cur, ks, obj);
+	} else if (rb_respond_to(input, oj_read_id)) {
+	    s = rb_funcall2(input, oj_read_id, 0, 0);
+	    len = RSTRING_LEN(s) + 1;
+	    json = ALLOC_N(char, len);
+	    strcpy(json, StringValuePtr(s));
 	} else {
-	    rb_ary_push(*cx->cur, obj);
-	}
-    }
-}
-
-static void
-cx_push(CX cx, VALUE obj, const char *key) {
-    if (0 == cx->cur) {
-	cx->cur = cx->stack;
-    } else {
-	if (cx->end <= cx->cur) {
-	    rb_raise(oj_parse_error_class, "too deeply nested");
+	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
 	}
-	cx_add(cx, obj, key);
-	cx->cur++;
     }
-    *cx->cur = obj;
-}
-
-static void
-hash_start(void *context, const char *key) {
-    cx_push((CX)context, rb_hash_new(), key);
-}
-
-static void
-col_end(void *context, const char *key) {
-    ((CX)context)->cur--;
-}
-
-static void
-array_start(void *context, const char *key) {
-    cx_push((CX)context, rb_ary_new(), key);
-}
-
-static void
-add_str(void *context, const char *str, const char *key) {
-    VALUE	s;
-
-    s = rb_str_new2(str);
-#if HAS_ENCODING_SUPPORT
-    rb_enc_associate(s, oj_utf8_encoding);
-#endif
-    cx_add((CX)context, s, key);
-}
-
-static void
-add_big(void *context, const char *str, const char *key) {
-    cx_add((CX)context, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(str)), key);
-}
-
-static void
-add_float(void *context, double num, const char *key) {
-    cx_add((CX)context, rb_float_new(num), key);
-}
-
-static void
-add_fixnum(void *context, int64_t num, const char *key) {
-    cx_add((CX)context, LONG2NUM(num), key);
-}
-
-static void
-add_true(void *context, const char *key) {
-    cx_add((CX)context, Qtrue, key);
-}
-
-static void
-add_false(void *context, const char *key) {
-    cx_add((CX)context, Qfalse, key);
-}
+    sajkey_parse(*argv, json);
+    xfree(json);
 
-static void
-add_nil(void *context, const char *key) {
-    cx_add((CX)context, Qnil, key);
+    return Qnil;
 }
-#endif

data/ext/oj/scp.c

@@ -0,0 +1,308 @@
+/* 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.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "oj.h"
+#include "parse.h"
+
+inline static int
+respond_to(VALUE obj, ID method) {
+#ifdef JRUBY_RUBY
+    /* There is a bug in JRuby where rb_respond_to() returns true (1) even if
+     * a method is private. */
+    {
+	VALUE	args[1];
+
+	*args = ID2SYM(method);
+	return (Qtrue == rb_funcall2(obj, rb_intern("respond_to?"), 1, args));
+    }
+#else
+    return rb_respond_to(obj, method);
+#endif
+}
+
+static VALUE
+noop_start(ParseInfo pi) {
+    return Qnil;
+}
+
+static void
+noop_end(ParseInfo pi) {
+}
+
+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_num(ParseInfo pi, NumInfo ni) {
+}
+
+static void
+noop_hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
+}
+
+static void
+noop_hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
+}
+
+static void
+noop_hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
+}
+
+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_value(ParseInfo pi, VALUE value) {
+}
+
+static void
+add_value(ParseInfo pi, VALUE val) {
+     rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, val);
+}
+
+static void
+add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+     rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, rstr);
+}
+
+static void
+add_num(ParseInfo pi, NumInfo ni) {
+    rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, oj_num_as_value(ni));
+}
+
+static VALUE
+start_hash(ParseInfo pi) {
+    return rb_funcall((VALUE)pi->cbc, oj_hash_start_id, 0);
+}
+
+static void
+end_hash(ParseInfo pi) {
+    rb_funcall((VALUE)pi->cbc, oj_hash_end_id, 0);
+}
+
+static VALUE
+start_array(ParseInfo pi) {
+    return rb_funcall((VALUE)pi->cbc, oj_array_start_id, 0);
+}
+
+static void
+end_array(ParseInfo pi) {
+    rb_funcall((VALUE)pi->cbc, oj_array_end_id, 0);
+}
+
+static VALUE
+hash_key(ParseInfo pi, const char *key, size_t klen) {
+    VALUE	rkey = rb_str_new(key, klen);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rkey, oj_utf8_encoding);
+#endif
+    if (Yes == pi->options.sym_key) {
+	rkey = rb_str_intern(rkey);
+    }
+    return rkey;
+}
+
+static void
+hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+    rb_funcall((VALUE)pi->cbc, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), rstr);
+}
+
+static void
+hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
+    rb_funcall((VALUE)pi->cbc, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), oj_num_as_value(ni));
+}
+
+static void
+hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
+    rb_funcall((VALUE)pi->cbc, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), value);
+}
+
+static void
+array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+    rb_funcall((VALUE)pi->cbc, oj_array_append_id, 2, stack_peek(&pi->stack)->val, rstr);
+}
+
+static void
+array_append_num(ParseInfo pi, NumInfo ni) {
+    rb_funcall((VALUE)pi->cbc, oj_array_append_id, 2, stack_peek(&pi->stack)->val, oj_num_as_value(ni));
+}
+
+static void
+array_append_value(ParseInfo pi, VALUE value) {
+    rb_funcall((VALUE)pi->cbc, oj_array_append_id, 2, stack_peek(&pi->stack)->val, value);
+}
+
+static VALUE
+protect_parse(VALUE pip) {
+    oj_parse2((ParseInfo)pip);
+
+    return Qnil;
+}
+
+VALUE
+oj_sc_parse(int argc, VALUE *argv, VALUE self) {
+    struct _ParseInfo	pi;
+    char		*buf = 0;
+    VALUE		input;
+    VALUE		handler;
+    int			line = 0;
+
+    if (argc < 2) {
+	rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.");
+    }
+    handler = *argv;;
+    input = argv[1];
+    pi.json = 0;
+    pi.options = oj_default_options;
+    if (3 == argc) {
+	oj_parse_options(argv[2], &pi.options);
+    }
+    pi.cbc = (void*)handler;
+
+    pi.start_hash = respond_to(handler, oj_hash_start_id) ? start_hash : noop_start;
+    pi.end_hash = respond_to(handler, oj_hash_end_id) ? end_hash : noop_end;
+    pi.start_array = respond_to(handler, oj_array_start_id) ? start_array : noop_start;
+    pi.end_array = respond_to(handler, oj_array_end_id) ? end_array : noop_end;
+    if (respond_to(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;
+    } 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;
+    }
+    if (respond_to(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;
+    } 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;
+    }
+    if (respond_to(handler, oj_add_value_id)) {
+	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;
+    }
+    if (rb_type(input) == T_STRING) {
+	pi.json = StringValuePtr(input);
+    } else {
+	VALUE	clas = rb_obj_class(input);
+	VALUE	s;
+
+	if (oj_stringio_class == clas) {
+	    s = rb_funcall2(input, oj_string_id, 0, 0);
+	    pi.json = StringValuePtr(input);
+#ifndef JRUBY_RUBY
+#if !IS_WINDOWS
+	    // JRuby gets confused with what is the real fileno.
+	} else if (rb_respond_to(input, oj_fileno_id) && Qnil != (s = rb_funcall(input, oj_fileno_id, 0))) {
+	    int		fd = FIX2INT(s);
+	    ssize_t	cnt;
+	    size_t	len = lseek(fd, 0, SEEK_END);
+
+	    lseek(fd, 0, SEEK_SET);
+	    buf = ALLOC_N(char, len + 1);
+	    pi.json = buf;
+	    if (0 >= (cnt = read(fd, (char*)pi.json, len)) || cnt != (ssize_t)len) {
+		if (0 != buf) {
+		    xfree(buf);
+		}
+		rb_raise(rb_eIOError, "failed to read from IO Object.");
+	    }
+	    ((char*)pi.json)[len] = '\0';
+#endif
+#endif
+	} else if (rb_respond_to(input, oj_read_id)) {
+	    s = rb_funcall2(input, oj_read_id, 0, 0);
+	    pi.json = StringValuePtr(s);
+	} else {
+	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
+	}
+    }
+    rb_protect(protect_parse, (VALUE)&pi, &line);
+    //oj_parse2(&pi);
+    if (0 != buf) {
+	xfree(buf);
+    }
+    stack_cleanup(&pi.stack);
+    if (0 != line) {
+	rb_jump_tag(line);
+    }
+    if (err_has(&pi.err)) {
+	oj_err_raise(&pi.err);
+    }
+    return Qnil;
+}