yaji 0.2.3-x86-mingw32

data/ext/yaji/api/yajl_gen.h

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2010, Lloyd Hilaiel.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  2. 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.
+ *
+ *  3. Neither the name of Lloyd Hilaiel 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 AUTHOR ``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 AUTHOR 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.
+ */
+
+/**
+ * \file yajl_gen.h
+ * Interface to YAJL's JSON generation facilities.
+ */
+
+#include "api/yajl_common.h"
+
+#ifndef __YAJL_GEN_H__
+#define __YAJL_GEN_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    /** generator status codes */
+    typedef enum {
+        /** no error */
+        yajl_gen_status_ok = 0,
+        /** at a point where a map key is generated, a function other than
+         *  yajl_gen_string was called */
+        yajl_gen_keys_must_be_strings,
+        /** YAJL's maximum generation depth was exceeded.  see
+         *  YAJL_MAX_DEPTH */
+        yajl_max_depth_exceeded,
+        /** A generator function (yajl_gen_XXX) was called while in an error
+         *  state */
+        yajl_gen_in_error_state,
+        /** A complete JSON document has been generated */
+        yajl_gen_generation_complete,
+        /** yajl_gen_double was passed an invalid floating point value
+         *  (infinity or NaN). */
+        yajl_gen_invalid_number,
+        /** A print callback was passed in, so there is no internal
+         * buffer to get from */
+        yajl_gen_no_buf
+    } yajl_gen_status;
+
+    /** an opaque handle to a generator */
+    typedef struct yajl_gen_t * yajl_gen;
+
+    /** a callback used for "printing" the results. */
+    typedef void (*yajl_print_t)(void * ctx,
+                                 const char * str,
+                                 unsigned int len);
+
+    /** configuration structure for the generator */
+    typedef struct {
+        /** generate indented (beautiful) output */
+        unsigned int beautify;
+        /** an opportunity to define an indent string.  such as \\t or
+         *  some number of spaces.  default is four spaces '    '.  This
+         *  member is only relevant when beautify is true */
+        const char * indentString;
+    } yajl_gen_config;
+
+    /** allocate a generator handle
+     *  \param config a pointer to a structure containing parameters which
+     *                configure the behavior of the json generator
+     *  \param allocFuncs an optional pointer to a structure which allows
+     *                    the client to overide the memory allocation
+     *                    used by yajl.  May be NULL, in which case
+     *                    malloc/free/realloc will be used.
+     *
+     *  \returns an allocated handle on success, NULL on failure (bad params)
+     */
+    YAJL_API yajl_gen yajl_gen_alloc(const yajl_gen_config * config,
+                                     const yajl_alloc_funcs * allocFuncs);
+
+    /** allocate a generator handle that will print to the specified
+     *  callback rather than storing the results in an internal buffer.
+     *  \param callback   a pointer to a printer function.  May be NULL
+     *                    in which case, the results will be store in an
+     *                    internal buffer.
+     *  \param config     a pointer to a structure containing parameters
+     *                    which configure the behavior of the json
+     *                    generator.
+     *  \param allocFuncs an optional pointer to a structure which allows
+     *                    the client to overide the memory allocation
+     *                    used by yajl.  May be NULL, in which case
+     *                    malloc/free/realloc will be used.
+     *  \param ctx        a context pointer that will be passed to the
+     *                    printer callback.
+     *
+     *  \returns an allocated handle on success, NULL on failure (bad params)
+     */
+    YAJL_API yajl_gen yajl_gen_alloc2(const yajl_print_t callback,
+                                      const yajl_gen_config * config,
+                                      const yajl_alloc_funcs * allocFuncs,
+                                      void * ctx);
+
+    /** free a generator handle */
+    YAJL_API void yajl_gen_free(yajl_gen handle);
+
+    YAJL_API yajl_gen_status yajl_gen_integer(yajl_gen hand, long int number);
+    /** generate a floating point number.  number may not be infinity or
+     *  NaN, as these have no representation in JSON.  In these cases the
+     *  generator will return 'yajl_gen_invalid_number' */
+    YAJL_API yajl_gen_status yajl_gen_double(yajl_gen hand, double number);
+    YAJL_API yajl_gen_status yajl_gen_number(yajl_gen hand,
+                                             const char * num,
+                                             unsigned int len);
+    YAJL_API yajl_gen_status yajl_gen_string(yajl_gen hand,
+                                             const unsigned char * str,
+                                             unsigned int len);
+    YAJL_API yajl_gen_status yajl_gen_null(yajl_gen hand);
+    YAJL_API yajl_gen_status yajl_gen_bool(yajl_gen hand, int boolean);
+    YAJL_API yajl_gen_status yajl_gen_map_open(yajl_gen hand);
+    YAJL_API yajl_gen_status yajl_gen_map_close(yajl_gen hand);
+    YAJL_API yajl_gen_status yajl_gen_array_open(yajl_gen hand);
+    YAJL_API yajl_gen_status yajl_gen_array_close(yajl_gen hand);
+
+    /** access the null terminated generator buffer.  If incrementally
+     *  outputing JSON, one should call yajl_gen_clear to clear the
+     *  buffer.  This allows stream generation. */
+    YAJL_API yajl_gen_status yajl_gen_get_buf(yajl_gen hand,
+                                              const unsigned char ** buf,
+                                              unsigned int * len);
+
+    /** clear yajl's output buffer, but maintain all internal generation
+     *  state.  This function will not "reset" the generator state, and is
+     *  intended to enable incremental JSON outputing. */
+    YAJL_API void yajl_gen_clear(yajl_gen hand);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/yaji/api/yajl_parse.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2010, Lloyd Hilaiel.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  2. 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.
+ *
+ *  3. Neither the name of Lloyd Hilaiel 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 AUTHOR ``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 AUTHOR 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.
+ */
+
+/**
+ * \file yajl_parse.h
+ * Interface to YAJL's JSON parsing facilities.
+ */
+
+#include "api/yajl_common.h"
+
+#ifndef __YAJL_PARSE_H__
+#define __YAJL_PARSE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    /** error codes returned from this interface */
+    typedef enum {
+        /** no error was encountered */
+        yajl_status_ok,
+        /** a client callback returned zero, stopping the parse */
+        yajl_status_client_canceled,
+        /** The parse cannot yet complete because more json input text
+         *  is required, call yajl_parse with the next buffer of input text.
+         *  (pertinent only when stream parsing) */
+        yajl_status_insufficient_data,
+        /** An error occured during the parse.  Call yajl_get_error for
+         *  more information about the encountered error */
+        yajl_status_error
+    } yajl_status;
+
+    /** attain a human readable, english, string for an error */
+    YAJL_API const char * yajl_status_to_string(yajl_status code);
+
+    /** an opaque handle to a parser */
+    typedef struct yajl_handle_t * yajl_handle;
+
+    /** yajl is an event driven parser.  this means as json elements are
+     *  parsed, you are called back to do something with the data.  The
+     *  functions in this table indicate the various events for which
+     *  you will be called back.  Each callback accepts a "context"
+     *  pointer, this is a void * that is passed into the yajl_parse
+     *  function which the client code may use to pass around context.
+     *
+     *  All callbacks return an integer.  If non-zero, the parse will
+     *  continue.  If zero, the parse will be canceled and
+     *  yajl_status_client_canceled will be returned from the parse.
+     *
+     *  Note about handling of numbers:
+     *    yajl will only convert numbers that can be represented in a double
+     *    or a long int.  All other numbers will be passed to the client
+     *    in string form using the yajl_number callback.  Furthermore, if
+     *    yajl_number is not NULL, it will always be used to return numbers,
+     *    that is yajl_integer and yajl_double will be ignored.  If
+     *    yajl_number is NULL but one of yajl_integer or yajl_double are
+     *    defined, parsing of a number larger than is representable
+     *    in a double or long int will result in a parse error.
+     */
+    typedef struct {
+        int (* yajl_null)(void * ctx);
+        int (* yajl_boolean)(void * ctx, int boolVal);
+        int (* yajl_integer)(void * ctx, long integerVal);
+        int (* yajl_double)(void * ctx, double doubleVal);
+        /** A callback which passes the string representation of the number
+         *  back to the client.  Will be used for all numbers when present */
+        int (* yajl_number)(void * ctx, const char * numberVal,
+                            unsigned int numberLen);
+
+        /** strings are returned as pointers into the JSON text when,
+         * possible, as a result, they are _not_ null padded */
+        int (* yajl_string)(void * ctx, const unsigned char * stringVal,
+                            unsigned int stringLen);
+
+        int (* yajl_start_map)(void * ctx);
+        int (* yajl_map_key)(void * ctx, const unsigned char * key,
+                             unsigned int stringLen);
+        int (* yajl_end_map)(void * ctx);
+
+        int (* yajl_start_array)(void * ctx);
+        int (* yajl_end_array)(void * ctx);
+    } yajl_callbacks;
+
+    /** configuration structure for the generator */
+    typedef struct {
+        /** if nonzero, javascript style comments will be allowed in
+         *  the json input, both slash star and slash slash */
+        unsigned int allowComments;
+        /** if nonzero, invalid UTF8 strings will cause a parse
+         *  error */
+        unsigned int checkUTF8;
+    } yajl_parser_config;
+
+    /** allocate a parser handle
+     *  \param callbacks  a yajl callbacks structure specifying the
+     *                    functions to call when different JSON entities
+     *                    are encountered in the input text.  May be NULL,
+     *                    which is only useful for validation.
+     *  \param config     configuration parameters for the parse.
+     *  \param ctx        a context pointer that will be passed to callbacks.
+     */
+    YAJL_API yajl_handle yajl_alloc(const yajl_callbacks * callbacks,
+                                    const yajl_parser_config * config,
+                                    const yajl_alloc_funcs * allocFuncs,
+                                    void * ctx);
+
+    /** free a parser handle */
+    YAJL_API void yajl_free(yajl_handle handle);
+
+    /** Parse some json!
+     *  \param hand - a handle to the json parser allocated with yajl_alloc
+     *  \param jsonText - a pointer to the UTF8 json text to be parsed
+     *  \param jsonTextLength - the length, in bytes, of input text
+     */
+    YAJL_API yajl_status yajl_parse(yajl_handle hand,
+                                    const unsigned char * jsonText,
+                                    unsigned int jsonTextLength);
+
+    /** Parse any remaining buffered json.
+     *  Since yajl is a stream-based parser, without an explicit end of
+     *  input, yajl sometimes can't decide if content at the end of the
+     *  stream is valid or not.  For example, if "1" has been fed in,
+     *  yajl can't know whether another digit is next or some character
+     *  that would terminate the integer token.
+     *
+     *  \param hand - a handle to the json parser allocated with yajl_alloc
+     */
+    YAJL_API yajl_status yajl_parse_complete(yajl_handle hand);
+
+    /** get an error string describing the state of the
+     *  parse.
+     *
+     *  If verbose is non-zero, the message will include the JSON
+     *  text where the error occured, along with an arrow pointing to
+     *  the specific char.
+     *
+     *  \returns A dynamically allocated string will be returned which should
+     *  be freed with yajl_free_error
+     */
+    YAJL_API unsigned char * yajl_get_error(yajl_handle hand, int verbose,
+                                            const unsigned char * jsonText,
+                                            unsigned int jsonTextLength);
+
+    /**
+     * get the amount of data consumed from the last chunk passed to YAJL.
+     *
+     * In the case of a successful parse this can help you understand if
+     * the entire buffer was consumed (which will allow you to handle
+     * "junk at end of input".
+     *
+     * In the event an error is encountered during parsing, this function
+     * affords the client a way to get the offset into the most recent
+     * chunk where the error occured.  0 will be returned if no error
+     * was encountered.
+     */
+    YAJL_API unsigned int yajl_get_bytes_consumed(yajl_handle hand);
+
+    /** free an error returned from yajl_get_error */
+    YAJL_API void yajl_free_error(yajl_handle hand, unsigned char * str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/yaji/api/yajl_version.h

@@ -0,0 +1,23 @@
+#ifndef YAJL_VERSION_H_
+#define YAJL_VERSION_H_
+
+#include "api/yajl_common.h"
+
+#define YAJL_MAJOR 1
+#define YAJL_MINOR 0
+#define YAJL_MICRO 12
+
+#define YAJL_VERSION ((YAJL_MAJOR * 10000) + (YAJL_MINOR * 100) + YAJL_MICRO)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int YAJL_API yajl_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YAJL_VERSION_H_ */
+

data/ext/yaji/extconf.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require 'mkmf'
+require 'rbconfig'
+
+def define(macro, value = nil)
+  $defs.push("-D #{[macro.upcase, value].compact.join('=')}")
+end
+
+$CFLAGS  << " #{ENV["CFLAGS"]}"
+$LDFLAGS << " #{ENV["LDFLAGS"]}"
+$LIBS    << " #{ENV["LIBS"]}"
+
+$CFLAGS << ' -std=c99 -Wall -funroll-loops -Wextra '
+$CFLAGS << ' -O0 -ggdb3 -pedantic ' if ENV['DEBUG']
+
+# have_library('yajl', 'yajl_parse', 'yajl/yajl_parse.h')
+
+define("READ_BUFSIZE", "8192")
+
+create_header("yaji_config.h")
+create_makefile("parser_ext")

data/ext/yaji/parser_ext.c

@@ -0,0 +1,442 @@
+/*
+ *  Author:: Couchbase <info@couchbase.com>
+ *  Copyright:: 2011 Couchbase, Inc.
+ *  License:: Apache License, Version 2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "parser_ext.h"
+
+#define STATUS_CONTINUE 1
+
+#define RB_P(OBJ) \
+	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("object_id"), 0)); \
+	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_str_new2(" ")); \
+	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("class"), 0)); \
+	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_str_new2(" ")); \
+	rb_funcall(rb_stderr, rb_intern("puts"), 1, rb_funcall(OBJ, rb_intern("inspect"), 0));
+
+#define RERAISE_PARSER_ERROR(parser) \
+{ \
+	unsigned char* emsg = yajl_get_error(parser->handle, 1, \
+			(const unsigned char*)RSTRING_PTR(p->chunk), \
+			RSTRING_LEN(p->chunk)); \
+	VALUE errobj = rb_exc_new2(c_parse_error, (const char*) emsg); \
+	yajl_free_error(parser->handle, emsg); \
+	rb_exc_raise(errobj); \
+}
+
+static int yaji_null(void *ctx)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_null, Qnil);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_boolean(void *ctx, int val)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_boolean, val ? Qtrue : Qfalse);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_number(void *ctx, const char *val, unsigned int len)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	char buf[len+1];
+	buf[len] = 0;
+	memcpy(buf, val, len);
+	VALUE rv;
+
+	if (memchr(buf, '.', len) || memchr(buf, 'e', len) || memchr(buf, 'E', len)) {
+		rv = rb_ary_new3(3, p->path_str, sym_number, rb_float_new(strtod(buf, NULL)));
+	} else {
+		rv = rb_ary_new3(3, p->path_str, sym_number, rb_cstr2inum(buf, 10));
+	}
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+#ifdef HAVE_RUBY_ENCODING_H
+#define YAJI_TO_STR(val, len, str)					    \
+	str = rb_str_new((const char *)val, len);			    \
+	rb_encoding *default_internal_enc = rb_default_internal_encoding(); \
+	rb_enc_associate(str, utf8_encoding);				    \
+	if (default_internal_enc) {					    \
+		str = rb_str_export_to_enc(str, default_internal_enc);	    \
+	}
+#else
+#define YAJI_TO_STR(val, len, str)					    \
+	str = rb_str_new((const char *)val, len);
+#endif
+
+static int yaji_string(void *ctx, const unsigned char *val, unsigned int len)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	VALUE str, rv;
+	YAJI_TO_STR((const char *)val, len, str);
+	rv = rb_ary_new3(3, p->path_str, sym_string, str);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_hash_key(void *ctx, const unsigned char *val, unsigned int len)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	VALUE key, rv;
+	YAJI_TO_STR((const char *)val, len, key);
+	key = p->symbolize_keys ? ID2SYM(rb_to_id(key)) : key;
+	if (p->key_in_use) {
+		rb_ary_pop(p->path);
+	} else {
+		p->key_in_use = 1;
+	}
+	p->path_str = rb_ary_join(p->path, rb_str_new2("/"));
+	rb_str_freeze(p->path_str);
+	rv = rb_ary_new3(3, p->path_str, sym_hash_key, key);
+	rb_ary_push(p->events, rv);
+	rb_ary_push(p->path, key);
+	p->path_str = rb_ary_join(p->path, rb_str_new2("/"));
+	rb_str_freeze(p->path_str);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_start_hash(void *ctx)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	p->key_in_use = 0;
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_start_hash, Qnil);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_end_hash(void *ctx)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	rb_ary_pop(p->path);
+	p->path_str = rb_ary_join(p->path, rb_str_new2("/"));
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_end_hash, Qnil);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_start_array(void *ctx)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_start_array, Qnil);
+	rb_ary_push(p->path, rb_str_new2(""));
+	p->path_str = rb_ary_join(p->path, rb_str_new2("/"));
+	rb_str_freeze(p->path_str);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static int yaji_end_array(void *ctx)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(ctx);
+
+	rb_ary_pop(p->path);
+	p->path_str = rb_ary_join(p->path, rb_str_new2("/"));
+
+	VALUE rv = rb_ary_new3(3, p->path_str, sym_end_array, Qnil);
+	rb_ary_push(p->events, rv);
+	return STATUS_CONTINUE;
+}
+
+static VALUE rb_yaji_parser_parse_chunk(VALUE chunk, VALUE self)
+{
+	yajl_status rc;
+	yaji_parser* p = (yaji_parser*) DATA_PTR(self);
+	const char* buf;
+	unsigned int len;
+	int i;
+
+	if (NIL_P(chunk) || (len = RSTRING_LEN(chunk)) == 0) {
+		return INT2FIX(0);
+	}
+	buf = RSTRING_PTR(chunk);
+	p->events = rb_ary_new();
+	p->chunk = chunk;
+	rc = yajl_parse(p->handle, (const unsigned char*)buf, len);
+	if (rc == yajl_status_error) {
+		RERAISE_PARSER_ERROR(p);
+	}
+	for (i=0; i<RARRAY_LEN(p->events); i++) {
+		rb_funcall(p->parser_cb, id_call, 1, RARRAY_PTR(p->events)[i]);
+	}
+	return rb_funcall(chunk, id_bytesize, 0, NULL);
+}
+
+static VALUE rb_yaji_parser_new(int argc, VALUE *argv, VALUE klass)
+{
+	yaji_parser* p;
+	VALUE opts, obj;
+
+	obj = Data_Make_Struct(klass, yaji_parser, rb_yaji_parser_mark, rb_yaji_parser_free, p);
+	p->handle = NULL;
+	p->config.allowComments = 1;
+	p->config.checkUTF8 = 1;
+	p->symbolize_keys = 0;
+	p->rbufsize = Qnil;
+	p->input = Qnil;
+	p->parser_cb = Qnil;
+
+	rb_scan_args(argc, argv, "11", &p->input, &opts);
+	if (TYPE(p->input) == T_STRING) {
+		p->input = rb_class_new_instance(1, &p->input, c_stringio);
+	} else if (rb_respond_to(p->input, id_perform) && rb_respond_to(p->input, id_on_body)) {
+		rb_block_call(p->input, id_on_body, 0, NULL, rb_yaji_parser_parse_chunk, obj);
+	} else if (!rb_respond_to(p->input, id_read)) {
+		rb_raise(c_parse_error, "input must be a String or IO or "
+				"something responding to #perform and #on_body e.g. Curl::Easy");
+	}
+	if (!NIL_P(opts)) {
+		Check_Type(opts, T_HASH);
+		if (rb_hash_aref(opts, sym_allow_comments) == Qfalse) {
+			p->config.allowComments = 0;
+		}
+		if (rb_hash_aref(opts, sym_check_utf8) == Qfalse) {
+			p->config.checkUTF8 = 0;
+		}
+		if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) {
+			p->symbolize_keys = 1;
+		}
+		p->rbufsize = rb_hash_aref(opts, sym_read_buffer_size);
+	}
+	if (NIL_P(p->rbufsize)) {
+		p->rbufsize = INT2FIX(READ_BUFSIZE);
+	} else {
+		Check_Type(p->rbufsize, T_FIXNUM);
+	}
+	p->handle = yajl_alloc(&yaji_callbacks, &p->config, NULL, (void *)obj);
+	rb_obj_call_init(obj, 0, 0);
+	return obj;
+}
+
+static VALUE rb_yaji_parser_init(int argc, VALUE *argv, VALUE self)
+{
+	return self;
+}
+
+
+static VALUE rb_yaji_parser_parse(int argc, VALUE* argv, VALUE self)
+{
+	yajl_status rc;
+	yaji_parser* p = (yaji_parser*) DATA_PTR(self);
+	int i;
+
+	rb_scan_args(argc, argv, "00&", &p->parser_cb);
+	RETURN_ENUMERATOR(self, argc, argv);
+
+	p->path = rb_ary_new();
+	rb_ary_push(p->path, rb_str_new("", 0));
+	p->path_str = rb_str_new("", 0);
+	p->chunk = Qnil;
+
+	if (rb_respond_to(p->input, id_perform)) {
+		rb_funcall(p->input, id_perform, 0);
+	} else {
+		p->chunk = rb_str_new(NULL, 0);
+		while (rb_funcall(p->input, id_read, 2, p->rbufsize, p->chunk) != Qnil) {
+			rb_yaji_parser_parse_chunk(p->chunk, self);
+		}
+	}
+
+	p->events = rb_ary_new();
+	rc = yajl_parse_complete(p->handle);
+
+	if (rc == yajl_status_error ||
+			(rc == yajl_status_insufficient_data && p->chunk != Qnil &&
+			 RSTRING_LEN(rb_funcall(p->chunk, id_strip, 0)) != 0)) {
+		RERAISE_PARSER_ERROR(p);
+	}
+	for (i=0; i<RARRAY_LEN(p->events); i++) {
+		rb_funcall(p->parser_cb, id_call, 1, RARRAY_PTR(p->events)[i]);
+	}
+
+	return Qnil;
+}
+
+static int rb_yaji_str_start_with(VALUE str, VALUE query)
+{
+	int i;
+	const char *ptr = RSTRING_PTR(str);
+	int len = RSTRING_LEN(str);
+	VALUE entry;
+
+	switch(TYPE(query)) {
+	case T_STRING:
+		return RSTRING_LEN(query) <= len && memcmp(RSTRING_PTR(query), ptr, RSTRING_LEN(query)) == 0;
+		break;
+	case T_ARRAY:
+		for (i=0; i<RARRAY_LEN(query); i++) {
+			entry = RARRAY_PTR(query)[i];
+			if (RSTRING_LEN(entry) <= len && memcmp(RSTRING_PTR(entry), ptr, RSTRING_LEN(entry)) == 0) {
+				return 1;
+			}
+		}
+		break;
+	}
+	return 0;
+}
+
+static VALUE rb_yaji_each_iter(VALUE chunk, VALUE* params_p)
+{
+	VALUE* params = (VALUE*)params_p;
+	VALUE path = rb_ary_shift(chunk);
+	VALUE event = rb_ary_shift(chunk);
+	VALUE value = rb_ary_shift(chunk);
+	VALUE proc = params[0];
+	VALUE stack = params[1];
+	VALUE query = params[2];
+	VALUE with_path = params[3];
+	VALUE last_entry, object, container, key, hash;
+
+	if (NIL_P(query) || rb_yaji_str_start_with(path, query)) {
+		if (event == sym_hash_key) {
+			rb_ary_push(stack, value);
+		} else if (event == sym_start_hash || event == sym_start_array) {
+			container = (event == sym_start_hash) ? rb_hash_new() : rb_ary_new();
+			last_entry = rb_ary_entry(stack, -1);
+			switch(TYPE(last_entry)) {
+			case T_STRING:
+				key = rb_ary_pop(stack);
+				hash = rb_ary_entry(stack, -1);
+				rb_hash_aset(hash, key, container);
+				break;
+			case T_ARRAY:
+				rb_ary_push(last_entry, container);
+			}
+			rb_ary_push(stack, container);
+		} else if (event == sym_end_hash || event == sym_end_array) {
+			object = rb_ary_pop(stack);
+			if (RARRAY_LEN(stack) == 0) {
+				if (with_path == Qnil || with_path == Qfalse) {
+					rb_funcall(proc, id_call, 1, object);
+				} else {
+					rb_funcall(proc, id_call, 1, rb_ary_new3(2, path, object));
+				}
+			}
+		} else {
+			last_entry = rb_ary_entry(stack, -1);
+			switch(TYPE(last_entry)) {
+			case T_STRING:
+				key = rb_ary_pop(stack);
+				hash = rb_ary_entry(stack, -1);
+				rb_hash_aset(hash, key, value);
+				break;
+			case T_ARRAY:
+				rb_ary_push(last_entry, value);
+				break;
+			case T_NIL:
+				if (with_path == Qnil || with_path == Qfalse) {
+					rb_funcall(proc, id_call, 1, value);
+				} else {
+					rb_funcall(proc, id_call, 1, rb_ary_new3(2, path, value));
+				}
+				break;
+			}
+		}
+	}
+	return Qnil;
+}
+
+static VALUE rb_yaji_parser_each(int argc, VALUE* argv, VALUE self)
+{
+	VALUE query, proc, options, params[4];
+	RETURN_ENUMERATOR(self, argc, argv);
+	rb_scan_args(argc, argv, "02&", &query, &options, &proc);
+	params[0] = proc;	    // callback
+	params[1] = rb_ary_new();   // stack
+	params[2] = query;
+	if (options != Qnil) {
+		Check_Type(options, T_HASH);
+		params[3] = rb_hash_aref(options, sym_with_path);
+	} else {
+		params[3] = Qnil;
+	}
+	rb_block_call(self, id_parse, 0, NULL, rb_yaji_each_iter, (VALUE)params);
+	return Qnil;
+}
+
+static void rb_yaji_parser_free(void *parser)
+{
+	yaji_parser* p = parser;
+	if (p) {
+		if (p->handle) {
+			yajl_free(p->handle);
+		}
+		free(p);
+	}
+}
+
+static void rb_yaji_parser_mark(void *parser)
+{
+	yaji_parser* p = parser;
+	if (p) {
+		rb_gc_mark(p->input);
+		rb_gc_mark(p->rbufsize);
+		rb_gc_mark(p->events);
+		rb_gc_mark(p->path);
+		rb_gc_mark(p->path_str);
+		rb_gc_mark(p->parser_cb);
+		rb_gc_mark(p->chunk);
+	}
+}
+
+/* Ruby Extension initializer */
+void Init_parser_ext() {
+	m_yaji = rb_define_module("YAJI");
+
+	c_parse_error = rb_define_class_under(m_yaji, "ParseError", rb_eStandardError);
+
+	c_yaji_parser = rb_define_class_under(m_yaji, "Parser", rb_cObject);
+	rb_define_const(c_yaji_parser, "READ_BUFFER_SIZE", INT2FIX(READ_BUFSIZE));
+	rb_define_singleton_method(c_yaji_parser, "new", rb_yaji_parser_new, -1);
+	rb_define_method(c_yaji_parser, "initialize", rb_yaji_parser_init, -1);
+	rb_define_method(c_yaji_parser, "parse", rb_yaji_parser_parse, -1);
+	rb_define_method(c_yaji_parser, "each", rb_yaji_parser_each, -1);
+
+	id_call = rb_intern("call");
+	id_read = rb_intern("read");
+	id_parse = rb_intern("parse");
+	id_strip = rb_intern("strip");
+	id_perform = rb_intern("perform");
+	id_on_body = rb_intern("on_body");
+	id_bytesize = rb_intern("bytesize");
+
+	sym_allow_comments = ID2SYM(rb_intern("allow_comments"));
+	sym_check_utf8 = ID2SYM(rb_intern("check_utf8"));
+	sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+	sym_read_buffer_size = ID2SYM(rb_intern("read_buffer_size"));
+	sym_with_path = ID2SYM(rb_intern("with_path"));
+	sym_null = ID2SYM(rb_intern("null"));
+	sym_boolean = ID2SYM(rb_intern("boolean"));
+	sym_number = ID2SYM(rb_intern("number"));
+	sym_string = ID2SYM(rb_intern("string"));
+	sym_hash_key = ID2SYM(rb_intern("hash_key"));
+	sym_start_hash = ID2SYM(rb_intern("start_hash"));
+	sym_end_hash = ID2SYM(rb_intern("end_hash"));
+	sym_start_array = ID2SYM(rb_intern("start_array"));
+	sym_end_array = ID2SYM(rb_intern("end_array"));
+
+#ifdef HAVE_RUBY_ENCODING_H
+	utf8_encoding = rb_utf8_encoding();
+#endif
+
+	rb_require("stringio");
+	c_stringio = rb_const_get(rb_cObject, rb_intern("StringIO"));
+}