scout 5.6.7 → 5.6.8.pre

data/vendor/json_pure/VERSION

@@ -1 +1 @@
-1.4.2
+1.8.0

data/vendor/json_pure/ext/json/ext/fbuffer/fbuffer.h

@@ -0,0 +1,181 @@
+
+#ifndef _FBUFFER_H_
+#define _FBUFFER_H_
+
+#include "ruby.h"
+
+#ifndef RHASH_SIZE
+#define RHASH_SIZE(hsh) (RHASH(hsh)->tbl->num_entries)
+#endif
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(val) (RFLOAT(val)->value)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ARRAY) RARRAY(ARRAY)->ptr
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ARRAY) RARRAY(ARRAY)->len
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(string) RSTRING(string)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(string) RSTRING(string)->len
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#define FORCE_UTF8(obj) rb_enc_associate((obj), rb_utf8_encoding())
+#else
+#define FORCE_UTF8(obj)
+#endif
+
+/* We don't need to guard objects for rbx, so let's do nothing at all. */
+#ifndef RB_GC_GUARD
+#define RB_GC_GUARD(object)
+#endif
+
+typedef struct FBufferStruct {
+    unsigned long initial_length;
+    char *ptr;
+    unsigned long len;
+    unsigned long capa;
+} FBuffer;
+
+#define FBUFFER_INITIAL_LENGTH_DEFAULT 1024
+
+#define FBUFFER_PTR(fb) (fb->ptr)
+#define FBUFFER_LEN(fb) (fb->len)
+#define FBUFFER_CAPA(fb) (fb->capa)
+#define FBUFFER_PAIR(fb) FBUFFER_PTR(fb), FBUFFER_LEN(fb)
+
+static FBuffer *fbuffer_alloc(unsigned long initial_length);
+static void fbuffer_free(FBuffer *fb);
+static void fbuffer_clear(FBuffer *fb);
+static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len);
+#ifdef JSON_GENERATOR
+static void fbuffer_append_long(FBuffer *fb, long number);
+#endif
+static void fbuffer_append_char(FBuffer *fb, char newchr);
+#ifdef JSON_GENERATOR
+static FBuffer *fbuffer_dup(FBuffer *fb);
+static VALUE fbuffer_to_s(FBuffer *fb);
+#endif
+
+static FBuffer *fbuffer_alloc(unsigned long initial_length)
+{
+    FBuffer *fb;
+    if (initial_length <= 0) initial_length = FBUFFER_INITIAL_LENGTH_DEFAULT;
+    fb = ALLOC(FBuffer);
+    memset((void *) fb, 0, sizeof(FBuffer));
+    fb->initial_length = initial_length;
+    return fb;
+}
+
+static void fbuffer_free(FBuffer *fb)
+{
+    if (fb->ptr) ruby_xfree(fb->ptr);
+    ruby_xfree(fb);
+}
+
+static void fbuffer_clear(FBuffer *fb)
+{
+    fb->len = 0;
+}
+
+static void fbuffer_inc_capa(FBuffer *fb, unsigned long requested)
+{
+    unsigned long required;
+
+    if (!fb->ptr) {
+        fb->ptr = ALLOC_N(char, fb->initial_length);
+        fb->capa = fb->initial_length;
+    }
+
+    for (required = fb->capa; requested > required - fb->len; required <<= 1);
+
+    if (required > fb->capa) {
+        REALLOC_N(fb->ptr, char, required);
+        fb->capa = required;
+    }
+}
+
+static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
+{
+    if (len > 0) {
+        fbuffer_inc_capa(fb, len);
+        MEMCPY(fb->ptr + fb->len, newstr, char, len);
+        fb->len += len;
+    }
+}
+
+#ifdef JSON_GENERATOR
+static void fbuffer_append_str(FBuffer *fb, VALUE str)
+{
+    const char *newstr = StringValuePtr(str);
+    unsigned long len = RSTRING_LEN(str);
+
+    RB_GC_GUARD(str);
+
+    fbuffer_append(fb, newstr, len);
+}
+#endif
+
+static void fbuffer_append_char(FBuffer *fb, char newchr)
+{
+    fbuffer_inc_capa(fb, 1);
+    *(fb->ptr + fb->len) = newchr;
+    fb->len++;
+}
+
+#ifdef JSON_GENERATOR
+static void freverse(char *start, char *end)
+{
+    char c;
+
+    while (end > start) {
+        c = *end, *end-- = *start, *start++ = c;
+    }
+}
+
+static long fltoa(long number, char *buf)
+{
+    static char digits[] = "0123456789";
+    long sign = number;
+    char* tmp = buf;
+
+    if (sign < 0) number = -number;
+    do *tmp++ = digits[number % 10]; while (number /= 10);
+    if (sign < 0) *tmp++ = '-';
+    freverse(buf, tmp - 1);
+    return tmp - buf;
+}
+
+static void fbuffer_append_long(FBuffer *fb, long number)
+{
+    char buf[20];
+    unsigned long len = fltoa(number, buf);
+    fbuffer_append(fb, buf, len);
+}
+
+static FBuffer *fbuffer_dup(FBuffer *fb)
+{
+    unsigned long len = fb->len;
+    FBuffer *result;
+
+    result = fbuffer_alloc(len);
+    fbuffer_append(result, FBUFFER_PAIR(fb));
+    return result;
+}
+
+static VALUE fbuffer_to_s(FBuffer *fb)
+{
+    VALUE result = rb_str_new(FBUFFER_PAIR(fb));
+    fbuffer_free(fb);
+    FORCE_UTF8(result);
+    return result;
+}
+#endif
+#endif

data/vendor/json_pure/ext/json/ext/generator/depend

@@ -0,0 +1 @@
+generator.o: generator.c generator.h $(srcdir)/../fbuffer/fbuffer.h

data/vendor/json_pure/ext/json/ext/generator/extconf.rb

@@ -1,16 +1,14 @@
 require 'mkmf'
-require 'rbconfig'
 
 unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
   $CFLAGS << ' -O3'
 end
 if CONFIG['CC'] =~ /gcc/
   $CFLAGS << ' -Wall'
-  #unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
-  #  $CFLAGS << ' -O0 -ggdb'
-  #end
+  unless $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
 end
 
-have_header("ruby/re.h") || have_header("re.h")
-have_header("ruby/encoding.h")
+$defs << "-DJSON_GENERATOR"
 create_makefile 'json/ext/generator'

data/vendor/json_pure/ext/json/ext/generator/generator.c

@@ -1,3 +1,4 @@
+#include "../fbuffer/fbuffer.h"
 #include "generator.h"
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -6,20 +7,22 @@ static ID i_encoding, i_encode;
 #endif
 
 static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,
-             mHash, mArray, mInteger, mFloat, mString, mString_Extend,
+             mHash, mArray, mFixnum, mBignum, mFloat, mString, mString_Extend,
              mTrueClass, mFalseClass, mNilClass, eGeneratorError,
-             eNestingError, CRegexp_MULTILINE, CJSON_SAFE_STATE_PROTOTYPE;
+             eNestingError, CRegexp_MULTILINE, CJSON_SAFE_STATE_PROTOTYPE,
+             i_SAFE_STATE_PROTOTYPE;
 
 static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
           i_object_nl, i_array_nl, i_max_nesting, i_allow_nan, i_ascii_only,
-          i_pack, i_unpack, i_create_id, i_extend, i_key_p, i_aref, i_send,
-          i_respond_to_p, i_match;
+          i_quirks_mode, i_pack, i_unpack, i_create_id, i_extend, i_key_p,
+          i_aref, i_send, i_respond_to_p, i_match, i_keys, i_depth,
+          i_buffer_initial_length, i_dup;
 
 /*
  * Copyright 2001-2004 Unicode, Inc.
- * 
+ *
  * Disclaimer
- * 
+ *
  * This source code is provided as is by Unicode, Inc. No claims are
  * made as to fitness for any particular purpose. No warranties of any
  * kind are expressed or implied. The recipient agrees to determine
@@ -27,9 +30,9 @@ static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
  * purchased on magnetic or optical media from Unicode, Inc., the
  * sole remedy for any claim will be exchange of defective media
  * within 90 days of receipt.
- * 
+ *
  * Limitations on Rights to Redistribute This Code
- * 
+ *
  * Unicode, Inc. hereby grants the right to freely use the information
  * supplied in this file in the creation of products supporting the
  * Unicode Standard, and to make copies of this file in any form
@@ -60,8 +63,8 @@ static const char trailingBytesForUTF8[256] = {
  * This table contains as many values as there might be trailing bytes
  * in a UTF-8 sequence.
  */
-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
-		     0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+    0x03C82080UL, 0xFA082080UL, 0x82082080UL };
 
 /*
  * Utility routine to tell whether a sequence of bytes is legal UTF-8.
@@ -73,7 +76,7 @@ static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080
  * If presented with a length > 4, this returns 0.  The Unicode
  * definition of UTF-8 goes up to 4-byte sequences.
  */
-static unsigned char isLegalUTF8(const UTF8 *source, int length)
+static unsigned char isLegalUTF8(const UTF8 *source, unsigned long length)
 {
     UTF8 a;
     const UTF8 *srcptr = source+length;
@@ -111,7 +114,7 @@ static void unicode_escape(char *buf, UTF16 character)
 }
 
 /* Escapes the UTF16 character and stores the result in the buffer buf, then
- * the buffer buf іs appended to the FBuffer buffer. */
+ * the buffer buf is appended to the FBuffer buffer. */
 static void unicode_escape_to_buffer(FBuffer *buffer, char buf[6], UTF16
         character)
 {
@@ -222,7 +225,7 @@ static void convert_UTF8_to_JSON_ASCII(FBuffer *buffer, VALUE string)
 static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
 {
     const char *ptr = RSTRING_PTR(string), *p;
-    int len = RSTRING_LEN(string), start = 0, end = 0;
+    unsigned long len = RSTRING_LEN(string), start = 0, end = 0;
     const char *escape = NULL;
     int escape_len;
     unsigned char c;
@@ -270,7 +273,18 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
                     escape_len = 2;
                     break;
                 default:
-                    end++;
+                    {
+                        unsigned short clen = trailingBytesForUTF8[c] + 1;
+                        if (end + clen > len) {
+                            rb_raise(rb_path2class("JSON::GeneratorError"),
+                                    "partial character in source, but hit end");
+                        }
+                        if (!isLegalUTF8((UTF8 *) p, clen)) {
+                            rb_raise(rb_path2class("JSON::GeneratorError"),
+                                    "source sequence is illegal/malformed utf-8");
+                        }
+                        end += clen;
+                    }
                     continue;
                     break;
             }
@@ -283,7 +297,7 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
     fbuffer_append(buffer, ptr + start, end - start);
 }
 
-static char *fstrndup(const char *ptr, int len) {
+static char *fstrndup(const char *ptr, unsigned long len) {
   char *result;
   if (len <= 0) return NULL;
   result = ALLOC_N(char, len);
@@ -291,119 +305,7 @@ static char *fstrndup(const char *ptr, int len) {
   return result;
 }
 
-/* fbuffer implementation */
-
-static FBuffer *fbuffer_alloc()
-{
-    FBuffer *fb = ALLOC(FBuffer);
-    memset((void *) fb, 0, sizeof(FBuffer));
-    fb->initial_length = FBUFFER_INITIAL_LENGTH;
-    return fb;
-}
-
-static FBuffer *fbuffer_alloc_with_length(unsigned int initial_length)
-{
-    FBuffer *fb;
-    assert(initial_length > 0);
-    fb = ALLOC(FBuffer);
-    memset((void *) fb, 0, sizeof(FBuffer));
-    fb->initial_length = initial_length;
-    return fb;
-}
-
-static void fbuffer_free(FBuffer *fb)
-{
-    if (fb->ptr) ruby_xfree(fb->ptr);
-    ruby_xfree(fb);
-}
-
-static void fbuffer_free_only_buffer(FBuffer *fb)
-{
-    ruby_xfree(fb);
-}
-
-static void fbuffer_clear(FBuffer *fb)
-{
-    fb->len = 0;
-}
-
-static void fbuffer_inc_capa(FBuffer *fb, unsigned int requested)
-{
-    unsigned int required;
-
-    if (!fb->ptr) {
-        fb->ptr = ALLOC_N(char, fb->initial_length);
-        fb->capa = fb->initial_length;
-    }
-
-    for (required = fb->capa; requested > required - fb->len; required <<= 1);
-
-    if (required > fb->capa) {
-        fb->ptr = (char *) REALLOC_N((long*) fb->ptr, char, required);
-        fb->capa = required;
-    }
-}
-
-static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned int len)
-{
-    if (len > 0) {
-        fbuffer_inc_capa(fb, len);
-        MEMCPY(fb->ptr + fb->len, newstr, char, len);
-        fb->len += len;
-    }
-}
-
-static void fbuffer_append_char(FBuffer *fb, char newchr)
-{
-    fbuffer_inc_capa(fb, 1);
-    *(fb->ptr + fb->len) = newchr;
-    fb->len++;
-}
-
-static void freverse(char *start, char *end)
-{
-	char c;
-
-	while (end > start) {
-		c = *end, *end-- = *start, *start++ = c;
-    }
-}
-
-static int fltoa(long number, char *buf)
-{
-	static char digits[] = "0123456789";
-	long sign = number;
-	char* tmp = buf;
-
-	if (sign < 0) number = -number;
-    do *tmp++ = digits[number % 10]; while (number /= 10);
-	if (sign < 0) *tmp++ = '-';
-	freverse(buf, tmp - 1);
-    return tmp - buf;
-}
-
-static void fbuffer_append_long(FBuffer *fb, long number)
-{
-    char buf[20];
-    int len = fltoa(number, buf);
-    fbuffer_append(fb, buf, len);
-}
-
-static FBuffer *fbuffer_dup(FBuffer *fb)
-{
-    int len = fb->len;
-    FBuffer *result;
-
-    if (len > 0) {
-        result = fbuffer_alloc_with_length(len);
-        fbuffer_append(result, FBUFFER_PAIR(fb));
-    } else {
-        result = fbuffer_alloc();
-    }
-    return result;
-}
-
-/* 
+/*
  * Document-module: JSON::Ext::Generator
  *
  * This is the JSON generator implemented as a C extension. It can be
@@ -416,37 +318,28 @@ static FBuffer *fbuffer_dup(FBuffer *fb)
  */
 
 /*
- * call-seq: to_json(state = nil, depth = 0)
+ * call-seq: to_json(state = nil)
  *
  * Returns a JSON string containing a JSON object, that is generated from
  * this Hash instance.
  * _state_ is a JSON::State object, that can also be used to configure the
  * produced JSON string output further.
- * _depth_ is used to find out nesting depth, to indent accordingly.
  */
 static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(object);
 }
 
 /*
- * call-seq: to_json(state = nil, depth = 0)
+ * call-seq: to_json(state = nil)
  *
  * Returns a JSON string containing a JSON array, that is generated from
  * this Array instance.
  * _state_ is a JSON::State object, that can also be used to configure the
  * produced JSON string output further.
- * _depth_ is used to find out nesting depth, to indent accordingly.
  */
 static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(array);
 }
 
 /*
@@ -454,12 +347,19 @@ static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
  *
  * Returns a JSON string representation for this Integer number.
  */
-static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
+static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(fixnum);
+}
+
+/*
+ * call-seq: to_json(*)
+ *
+ * Returns a JSON string representation for this Integer number.
+ */
+static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self)
+{
+    GENERATE_JSON(bignum);
 }
 
 /*
@@ -469,10 +369,7 @@ static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
  */
 static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(float);
 }
 
 /*
@@ -494,10 +391,7 @@ static VALUE mString_included_s(VALUE self, VALUE modul) {
  */
 static VALUE mString_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(string);
 }
 
 /*
@@ -552,10 +446,7 @@ static VALUE mString_Extend_json_create(VALUE self, VALUE o)
  */
 static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(true);
 }
 
 /*
@@ -565,22 +456,17 @@ static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self)
  */
 static VALUE mFalseClass_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(false);
 }
 
 /*
  * call-seq: to_json(*)
  *
+ * Returns a JSON string for nil: 'null'.
  */
 static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
-    rb_scan_args(argc, argv, "02", &state, &depth);
-    state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, self, depth);
+    GENERATE_JSON(null);
 }
 
 /*
@@ -592,12 +478,12 @@ static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self)
  */
 static VALUE mObject_to_json(int argc, VALUE *argv, VALUE self)
 {
-    VALUE state, depth;
+    VALUE state;
     VALUE string = rb_funcall(self, i_to_s, 0);
-    rb_scan_args(argc, argv, "02", &state, &depth);
+    rb_scan_args(argc, argv, "01", &state);
     Check_Type(string, T_STRING);
     state = cState_from_state_s(cState, state);
-    return cState_partial_generate(state, string, depth);
+    return cState_partial_generate(state, string);
 }
 
 static void State_free(JSON_Generator_State *state)
@@ -616,6 +502,7 @@ static void State_free(JSON_Generator_State *state)
 static JSON_Generator_State *State_allocate()
 {
     JSON_Generator_State *state = ALLOC(JSON_Generator_State);
+    MEMZERO(state, JSON_Generator_State, 1);
     return state;
 }
 
@@ -635,54 +522,51 @@ static VALUE cState_configure(VALUE self, VALUE opts)
 {
     VALUE tmp;
     GET_STATE(self);
-    tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
+    tmp = rb_check_convert_type(opts, T_HASH, "Hash", "to_hash");
     if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
-    if (NIL_P(tmp)) {
-        rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash");
-    }
     opts = tmp;
     tmp = rb_hash_aref(opts, ID2SYM(i_indent));
     if (RTEST(tmp)) {
-        int len;
+        unsigned long len;
         Check_Type(tmp, T_STRING);
         len = RSTRING_LEN(tmp);
-        state->indent = fstrndup(RSTRING_PTR(tmp), len);
+        state->indent = fstrndup(RSTRING_PTR(tmp), len + 1);
         state->indent_len = len;
     }
     tmp = rb_hash_aref(opts, ID2SYM(i_space));
     if (RTEST(tmp)) {
-        int len;
+        unsigned long len;
         Check_Type(tmp, T_STRING);
         len = RSTRING_LEN(tmp);
-        state->space = fstrndup(RSTRING_PTR(tmp), len);
+        state->space = fstrndup(RSTRING_PTR(tmp), len + 1);
         state->space_len = len;
     }
     tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
     if (RTEST(tmp)) {
-        int len;
+        unsigned long len;
         Check_Type(tmp, T_STRING);
         len = RSTRING_LEN(tmp);
-        state->space_before = fstrndup(RSTRING_PTR(tmp), len);
+        state->space_before = fstrndup(RSTRING_PTR(tmp), len + 1);
         state->space_before_len = len;
     }
     tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
     if (RTEST(tmp)) {
-        int len;
+        unsigned long len;
         Check_Type(tmp, T_STRING);
         len = RSTRING_LEN(tmp);
-        state->array_nl = fstrndup(RSTRING_PTR(tmp), len);
+        state->array_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
         state->array_nl_len = len;
     }
     tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
     if (RTEST(tmp)) {
-        int len;
+        unsigned long len;
         Check_Type(tmp, T_STRING);
         len = RSTRING_LEN(tmp);
-        state->object_nl = fstrndup(RSTRING_PTR(tmp), len);
+        state->object_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
         state->object_nl_len = len;
     }
     tmp = ID2SYM(i_max_nesting);
-    state->max_nesting = 19;
+    state->max_nesting = 100;
     if (option_given_p(opts, tmp)) {
         VALUE max_nesting = rb_hash_aref(opts, tmp);
         if (RTEST(max_nesting)) {
@@ -692,13 +576,48 @@ static VALUE cState_configure(VALUE self, VALUE opts)
             state->max_nesting = 0;
         }
     }
+    tmp = ID2SYM(i_depth);
+    state->depth = 0;
+    if (option_given_p(opts, tmp)) {
+        VALUE depth = rb_hash_aref(opts, tmp);
+        if (RTEST(depth)) {
+            Check_Type(depth, T_FIXNUM);
+            state->depth = FIX2LONG(depth);
+        } else {
+            state->depth = 0;
+        }
+    }
+    tmp = ID2SYM(i_buffer_initial_length);
+    if (option_given_p(opts, tmp)) {
+        VALUE buffer_initial_length = rb_hash_aref(opts, tmp);
+        if (RTEST(buffer_initial_length)) {
+            long initial_length;
+            Check_Type(buffer_initial_length, T_FIXNUM);
+            initial_length = FIX2LONG(buffer_initial_length);
+            if (initial_length > 0) state->buffer_initial_length = initial_length;
+        }
+    }
     tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
     state->allow_nan = RTEST(tmp);
     tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
     state->ascii_only = RTEST(tmp);
+    tmp = rb_hash_aref(opts, ID2SYM(i_quirks_mode));
+    state->quirks_mode = RTEST(tmp);
     return self;
 }
 
+static void set_state_ivars(VALUE hash, VALUE state)
+{
+    VALUE ivars = rb_obj_instance_variables(state);
+    int i = 0;
+    for (i = 0; i < RARRAY_LEN(ivars); i++) {
+        VALUE key = rb_funcall(rb_ary_entry(ivars, i), i_to_s, 0);
+        long key_len = RSTRING_LEN(key);
+        VALUE value = rb_iv_get(state, StringValueCStr(key));
+        rb_hash_aset(hash, rb_str_intern(rb_str_substr(key, 1, key_len - 1)), value);
+    }
+}
+
 /*
  * call-seq: to_h
  *
@@ -709,6 +628,7 @@ static VALUE cState_to_h(VALUE self)
 {
     VALUE result = rb_hash_new();
     GET_STATE(self);
+    set_state_ivars(result, self);
     rb_hash_aset(result, ID2SYM(i_indent), rb_str_new(state->indent, state->indent_len));
     rb_hash_aset(result, ID2SYM(i_space), rb_str_new(state->space, state->space_len));
     rb_hash_aset(result, ID2SYM(i_space_before), rb_str_new(state->space_before, state->space_before_len));
@@ -716,7 +636,10 @@ static VALUE cState_to_h(VALUE self)
     rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len));
     rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse);
+    rb_hash_aset(result, ID2SYM(i_quirks_mode), state->quirks_mode ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
+    rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth));
+    rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length));
     return result;
 }
 
@@ -727,186 +650,226 @@ static VALUE cState_to_h(VALUE self)
 */
 static VALUE cState_aref(VALUE self, VALUE name)
 {
-    GET_STATE(self);
+    name = rb_funcall(name, i_to_s, 0);
     if (RTEST(rb_funcall(self, i_respond_to_p, 1, name))) {
         return rb_funcall(self, i_send, 1, name);
     } else {
-        return Qnil;
+        return rb_ivar_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
     }
 }
 
-static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj, long depth)
+/*
+* call-seq: []=(name, value)
+*
+* Set the attribute name to value.
+*/
+static VALUE cState_aset(VALUE self, VALUE name, VALUE value)
 {
-    VALUE tmp;
-    switch (TYPE(obj)) {
-        case T_HASH:
-            {
-                char *object_nl = state->object_nl;
-                long object_nl_len = state->object_nl_len;
-                char *indent = state->indent;
-                long indent_len = state->indent_len;
-                long max_nesting = state->max_nesting;
-                char *delim = FBUFFER_PTR(state->object_delim);
-                long delim_len = FBUFFER_LEN(state->object_delim);
-                char *delim2 = FBUFFER_PTR(state->object_delim2);
-                long delim2_len = FBUFFER_LEN(state->object_delim2);
-                int i, j;
-                VALUE key, key_to_s, keys;
-                depth++;
-                if (max_nesting != 0 && depth > max_nesting) {
-                    fbuffer_free(buffer);
-                    rb_raise(eNestingError, "nesting of %ld is too deep", depth);
-                }
-                fbuffer_append_char(buffer, '{');
-                keys = rb_funcall(obj, rb_intern("keys"), 0);
-                for(i = 0; i < RARRAY_LEN(keys); i++) {
-                    if (i > 0) fbuffer_append(buffer, delim, delim_len);
-                    if (object_nl) {
-                        fbuffer_append(buffer, object_nl, object_nl_len);
-                    }
-                    if (indent) {
-                        for (j = 0; j < depth; j++) {
-                            fbuffer_append(buffer, indent, indent_len);
-                        }
-                    }
-                    key = rb_ary_entry(keys, i);
-                    key_to_s = rb_funcall(key, i_to_s, 0);
-                    Check_Type(key_to_s, T_STRING);
-                    generate_json(buffer, Vstate, state, key_to_s, depth);
-                    fbuffer_append(buffer, delim2, delim2_len);
-                    generate_json(buffer, Vstate, state, rb_hash_aref(obj, key), depth);
-                }
-                depth--;
-                if (object_nl) {
-                    fbuffer_append(buffer, object_nl, object_nl_len);
-                    if (indent) {
-                        for (j = 0; j < depth; j++) {
-                            fbuffer_append(buffer, indent, indent_len);
-                        }
-                    }
-                }
-                fbuffer_append_char(buffer, '}');
-            }
-            break;
-        case T_ARRAY:
-            {
-                char *array_nl = state->array_nl;
-                long array_nl_len = state->array_nl_len;
-                char *indent = state->indent;
-                long indent_len = state->indent_len;
-                long max_nesting = state->max_nesting;
-                char *delim = FBUFFER_PTR(state->array_delim);
-                long delim_len = FBUFFER_LEN(state->array_delim);
-                int i, j;
-                depth++;
-                if (max_nesting != 0 && depth > max_nesting) {
-                    fbuffer_free(buffer);
-                    rb_raise(eNestingError, "nesting of %ld is too deep", depth);
-                }
-                fbuffer_append_char(buffer, '[');
-                if (array_nl) fbuffer_append(buffer, array_nl, array_nl_len);
-                for(i = 0; i < RARRAY_LEN(obj); i++) {
-                    if (i > 0) fbuffer_append(buffer, delim, delim_len);
-                    if (indent) {
-                        for (j = 0; j < depth; j++) {
-                            fbuffer_append(buffer, indent, indent_len);
-                        }
-                    }
-                    generate_json(buffer, Vstate, state, rb_ary_entry(obj, i), depth);
-                }
-                depth--;
-                if (array_nl) {
-                    fbuffer_append(buffer, array_nl, array_nl_len);
-                    if (indent) {
-                        for (j = 0; j < depth; j++) {
-                            fbuffer_append(buffer, indent, indent_len);
-                        }
-                    }
-                }
-                fbuffer_append_char(buffer, ']');
+    VALUE name_writer;
+
+    name = rb_funcall(name, i_to_s, 0);
+    name_writer = rb_str_cat2(rb_str_dup(name), "=");
+    if (RTEST(rb_funcall(self, i_respond_to_p, 1, name_writer))) {
+        return rb_funcall(self, i_send, 2, name_writer, value);
+    } else {
+        rb_ivar_set(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)), value);
+    }
+    return Qnil;
+}
+
+static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    char *object_nl = state->object_nl;
+    long object_nl_len = state->object_nl_len;
+    char *indent = state->indent;
+    long indent_len = state->indent_len;
+    long max_nesting = state->max_nesting;
+    char *delim = FBUFFER_PTR(state->object_delim);
+    long delim_len = FBUFFER_LEN(state->object_delim);
+    char *delim2 = FBUFFER_PTR(state->object_delim2);
+    long delim2_len = FBUFFER_LEN(state->object_delim2);
+    long depth = ++state->depth;
+    int i, j;
+    VALUE key, key_to_s, keys;
+    if (max_nesting != 0 && depth > max_nesting) {
+        fbuffer_free(buffer);
+        rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
+    }
+    fbuffer_append_char(buffer, '{');
+    keys = rb_funcall(obj, i_keys, 0);
+    for(i = 0; i < RARRAY_LEN(keys); i++) {
+        if (i > 0) fbuffer_append(buffer, delim, delim_len);
+        if (object_nl) {
+            fbuffer_append(buffer, object_nl, object_nl_len);
+        }
+        if (indent) {
+            for (j = 0; j < depth; j++) {
+                fbuffer_append(buffer, indent, indent_len);
             }
-            break;
-        case T_STRING:
-            fbuffer_append_char(buffer, '"');
-#ifdef HAVE_RUBY_ENCODING_H
-            obj = rb_funcall(obj, i_encode, 1, CEncoding_UTF_8);
-#endif
-            if (state->ascii_only) {
-                convert_UTF8_to_JSON_ASCII(buffer, obj);
-            } else {
-                convert_UTF8_to_JSON(buffer, obj);
+        }
+        key = rb_ary_entry(keys, i);
+        key_to_s = rb_funcall(key, i_to_s, 0);
+        Check_Type(key_to_s, T_STRING);
+        generate_json(buffer, Vstate, state, key_to_s);
+        fbuffer_append(buffer, delim2, delim2_len);
+        generate_json(buffer, Vstate, state, rb_hash_aref(obj, key));
+    }
+    depth = --state->depth;
+    if (object_nl) {
+        fbuffer_append(buffer, object_nl, object_nl_len);
+        if (indent) {
+            for (j = 0; j < depth; j++) {
+                fbuffer_append(buffer, indent, indent_len);
             }
-            fbuffer_append_char(buffer, '"');
-            break;
-        case T_NIL:
-            fbuffer_append(buffer, "null", 4);
-            break;
-        case T_FALSE:
-            fbuffer_append(buffer, "false", 5);
-            break;
-        case T_TRUE:
-            fbuffer_append(buffer, "true", 4);
-            break;
-        case T_FIXNUM:
-            fbuffer_append_long(buffer, FIX2LONG(obj));
-            break;
-        case T_BIGNUM:
-            tmp = rb_funcall(obj, i_to_s, 0);
-            fbuffer_append(buffer, RSTRING_PAIR(tmp));
-            break;
-        case T_FLOAT:
-            {
-                double value = RFLOAT_VALUE(obj);
-                char allow_nan = state->allow_nan;
-                tmp = rb_funcall(obj, i_to_s, 0);
-                if (!allow_nan) {
-                    if (isinf(value)) {
-                        fbuffer_free(buffer);
-                        rb_raise(eGeneratorError, "%u: %s not allowed in JSON", __LINE__, StringValueCStr(tmp));
-                    } else if (isnan(value)) {
-                        fbuffer_free(buffer);
-                        rb_raise(eGeneratorError, "%u: %s not allowed in JSON", __LINE__, StringValueCStr(tmp));
-                    }
-                }
-                fbuffer_append(buffer, RSTRING_PAIR(tmp));
+        }
+    }
+    fbuffer_append_char(buffer, '}');
+}
+
+static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    char *array_nl = state->array_nl;
+    long array_nl_len = state->array_nl_len;
+    char *indent = state->indent;
+    long indent_len = state->indent_len;
+    long max_nesting = state->max_nesting;
+    char *delim = FBUFFER_PTR(state->array_delim);
+    long delim_len = FBUFFER_LEN(state->array_delim);
+    long depth = ++state->depth;
+    int i, j;
+    if (max_nesting != 0 && depth > max_nesting) {
+        fbuffer_free(buffer);
+        rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
+    }
+    fbuffer_append_char(buffer, '[');
+    if (array_nl) fbuffer_append(buffer, array_nl, array_nl_len);
+    for(i = 0; i < RARRAY_LEN(obj); i++) {
+        if (i > 0) fbuffer_append(buffer, delim, delim_len);
+        if (indent) {
+            for (j = 0; j < depth; j++) {
+                fbuffer_append(buffer, indent, indent_len);
             }
-            break;
-        default:
-            if (rb_respond_to(obj, i_to_json)) {
-                tmp = rb_funcall(obj, i_to_json, 2, Vstate, INT2FIX(depth + 1));
-                Check_Type(tmp, T_STRING);
-                fbuffer_append(buffer, RSTRING_PAIR(tmp));
-            } else {
-                tmp = rb_funcall(obj, i_to_s, 0);
-                Check_Type(tmp, T_STRING);
-                generate_json(buffer, Vstate, state, tmp, depth + 1);
+        }
+        generate_json(buffer, Vstate, state, rb_ary_entry(obj, i));
+    }
+    state->depth = --depth;
+    if (array_nl) {
+        fbuffer_append(buffer, array_nl, array_nl_len);
+        if (indent) {
+            for (j = 0; j < depth; j++) {
+                fbuffer_append(buffer, indent, indent_len);
             }
-            break;
+        }
     }
+    fbuffer_append_char(buffer, ']');
 }
 
-/*
- * call-seq: partial_generate(obj)
- *
- * Generates a part of a JSON document from object +obj+ and returns the
- * result.
- */
-static VALUE cState_partial_generate(VALUE self, VALUE obj, VALUE depth)
+static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    fbuffer_append_char(buffer, '"');
+#ifdef HAVE_RUBY_ENCODING_H
+    obj = rb_funcall(obj, i_encode, 1, CEncoding_UTF_8);
+#endif
+    if (state->ascii_only) {
+        convert_UTF8_to_JSON_ASCII(buffer, obj);
+    } else {
+        convert_UTF8_to_JSON(buffer, obj);
+    }
+    fbuffer_append_char(buffer, '"');
+}
+
+static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    fbuffer_append(buffer, "null", 4);
+}
+
+static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    fbuffer_append(buffer, "false", 5);
+}
+
+static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    fbuffer_append(buffer, "true", 4);
+}
+
+static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    fbuffer_append_long(buffer, FIX2LONG(obj));
+}
+
+static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    VALUE tmp = rb_funcall(obj, i_to_s, 0);
+    fbuffer_append_str(buffer, tmp);
+}
+
+static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    double value = RFLOAT_VALUE(obj);
+    char allow_nan = state->allow_nan;
+    VALUE tmp = rb_funcall(obj, i_to_s, 0);
+    if (!allow_nan) {
+        if (isinf(value)) {
+            fbuffer_free(buffer);
+            rb_raise(eGeneratorError, "%u: %s not allowed in JSON", __LINE__, StringValueCStr(tmp));
+        } else if (isnan(value)) {
+            fbuffer_free(buffer);
+            rb_raise(eGeneratorError, "%u: %s not allowed in JSON", __LINE__, StringValueCStr(tmp));
+        }
+    }
+    fbuffer_append_str(buffer, tmp);
+}
+
+static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
 {
-    VALUE result;
-    FBuffer *buffer = fbuffer_alloc();
+    VALUE tmp;
+    VALUE klass = CLASS_OF(obj);
+    if (klass == rb_cHash) {
+        generate_json_object(buffer, Vstate, state, obj);
+    } else if (klass == rb_cArray) {
+        generate_json_array(buffer, Vstate, state, obj);
+    } else if (klass == rb_cString) {
+        generate_json_string(buffer, Vstate, state, obj);
+    } else if (obj == Qnil) {
+        generate_json_null(buffer, Vstate, state, obj);
+    } else if (obj == Qfalse) {
+        generate_json_false(buffer, Vstate, state, obj);
+    } else if (obj == Qtrue) {
+        generate_json_true(buffer, Vstate, state, obj);
+    } else if (klass == rb_cFixnum) {
+        generate_json_fixnum(buffer, Vstate, state, obj);
+    } else if (klass == rb_cBignum) {
+        generate_json_bignum(buffer, Vstate, state, obj);
+    } else if (klass == rb_cFloat) {
+        generate_json_float(buffer, Vstate, state, obj);
+    } else if (rb_respond_to(obj, i_to_json)) {
+        tmp = rb_funcall(obj, i_to_json, 1, Vstate);
+        Check_Type(tmp, T_STRING);
+        fbuffer_append_str(buffer, tmp);
+    } else {
+        tmp = rb_funcall(obj, i_to_s, 0);
+        Check_Type(tmp, T_STRING);
+        generate_json(buffer, Vstate, state, tmp);
+    }
+}
+
+static FBuffer *cState_prepare_buffer(VALUE self)
+{
+    FBuffer *buffer;
     GET_STATE(self);
+    buffer = fbuffer_alloc(state->buffer_initial_length);
 
     if (state->object_delim) {
         fbuffer_clear(state->object_delim);
     } else {
-        state->object_delim = fbuffer_alloc_with_length(16);
+        state->object_delim = fbuffer_alloc(16);
     }
     fbuffer_append_char(state->object_delim, ',');
     if (state->object_delim2) {
         fbuffer_clear(state->object_delim2);
     } else {
-        state->object_delim2 = fbuffer_alloc_with_length(16);
+        state->object_delim2 = fbuffer_alloc(16);
     }
     fbuffer_append_char(state->object_delim2, ':');
     if (state->space) fbuffer_append(state->object_delim2, state->space, state->space_len);
@@ -914,16 +877,34 @@ static VALUE cState_partial_generate(VALUE self, VALUE obj, VALUE depth)
     if (state->array_delim) {
         fbuffer_clear(state->array_delim);
     } else {
-        state->array_delim = fbuffer_alloc_with_length(16);
+        state->array_delim = fbuffer_alloc(16);
     }
     fbuffer_append_char(state->array_delim, ',');
     if (state->array_nl) fbuffer_append(state->array_delim, state->array_nl, state->array_nl_len);
+    return buffer;
+}
 
-    generate_json(buffer, self, state, obj, NIL_P(depth) ? 0 : FIX2INT(depth));
-    result = rb_str_new(FBUFFER_PAIR(buffer));
-    fbuffer_free(buffer);
-    FORCE_UTF8(result);
-    return result;
+static VALUE cState_partial_generate(VALUE self, VALUE obj)
+{
+    FBuffer *buffer = cState_prepare_buffer(self);
+    GET_STATE(self);
+    generate_json(buffer, self, state, obj);
+    return fbuffer_to_s(buffer);
+}
+
+/*
+ * This function returns true if string is either a JSON array or JSON object.
+ * It might suffer from false positives, e. g. syntactically incorrect JSON in
+ * the string or certain UTF-8 characters on the right hand side.
+ */
+static int isArrayOrObject(VALUE string)
+{
+    long string_len = RSTRING_LEN(string);
+    char *p = RSTRING_PTR(string), *q = p + string_len - 1;
+    if (string_len < 2) return 0;
+    for (; p < q && isspace((unsigned char)*p); p++);
+    for (; q > p && isspace((unsigned char)*q); q--);
+    return (*p == '[' && *q == ']') || (*p == '{' && *q == '}');
 }
 
 /*
@@ -935,12 +916,9 @@ static VALUE cState_partial_generate(VALUE self, VALUE obj, VALUE depth)
  */
 static VALUE cState_generate(VALUE self, VALUE obj)
 {
-    VALUE result = cState_partial_generate(self, obj, Qnil);
-    VALUE re, args[2];
-    args[0] = rb_str_new2("\\A\\s*(?:\\[.*\\]|\\{.*\\})\\s*\\Z");
-    args[1] = CRegexp_MULTILINE;
-    re = rb_class_new_instance(2, args, rb_cRegexp);
-    if (NIL_P(rb_funcall(re, i_match, 1, result))) {
+    VALUE result = cState_partial_generate(self, obj);
+    GET_STATE(self);
+    if (!state->quirks_mode && !isArrayOrObject(result)) {
         rb_raise(eGeneratorError, "only generation of JSON objects or arrays allowed");
     }
     return result;
@@ -956,18 +934,22 @@ static VALUE cState_generate(VALUE self, VALUE obj)
  * * *indent*: a string used to indent levels (default: ''),
  * * *space*: a string that is put after, a : or , delimiter (default: ''),
  * * *space_before*: a string that is put before a : pair delimiter (default: ''),
- * * *object_nl*: a string that is put at the end of a JSON object (default: ''), 
+ * * *object_nl*: a string that is put at the end of a JSON object (default: ''),
  * * *array_nl*: a string that is put at the end of a JSON array (default: ''),
  * * *allow_nan*: true if NaN, Infinity, and -Infinity should be
  *   generated, otherwise an exception is thrown, if these values are
  *   encountered. This options defaults to false.
+ * * *quirks_mode*: Enables quirks_mode for parser, that is for example
+ *   generating single JSON values instead of documents is possible.
+ * * *buffer_initial_length*: sets the initial length of the generator's
+ *   internal buffer.
  */
 static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE opts;
     GET_STATE(self);
-    MEMZERO(state, JSON_Generator_State, 1);
-    state->max_nesting = 19;
+    state->max_nesting = 100;
+    state->buffer_initial_length = FBUFFER_INITIAL_LENGTH_DEFAULT;
     rb_scan_args(argc, argv, "01", &opts);
     if (!NIL_P(opts)) cState_configure(self, opts);
     return self;
@@ -1014,9 +996,9 @@ static VALUE cState_from_state_s(VALUE self, VALUE opts)
         return rb_funcall(self, i_new, 1, opts);
     } else {
         if (NIL_P(CJSON_SAFE_STATE_PROTOTYPE)) {
-            CJSON_SAFE_STATE_PROTOTYPE = rb_const_get(mJSON, rb_intern("SAFE_STATE_PROTOTYPE"));
+            CJSON_SAFE_STATE_PROTOTYPE = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
         }
-        return CJSON_SAFE_STATE_PROTOTYPE;
+        return rb_funcall(CJSON_SAFE_STATE_PROTOTYPE, i_dup, 0);
     }
 }
 
@@ -1028,7 +1010,7 @@ static VALUE cState_from_state_s(VALUE self, VALUE opts)
 static VALUE cState_indent(VALUE self)
 {
     GET_STATE(self);
-    return state->indent ? rb_str_new2(state->indent) : rb_str_new2("");
+    return state->indent ? rb_str_new(state->indent, state->indent_len) : rb_str_new2("");
 }
 
 /*
@@ -1038,16 +1020,20 @@ static VALUE cState_indent(VALUE self)
  */
 static VALUE cState_indent_set(VALUE self, VALUE indent)
 {
+    unsigned long len;
     GET_STATE(self);
     Check_Type(indent, T_STRING);
-    if (RSTRING_LEN(indent) == 0) {
+    len = RSTRING_LEN(indent);
+    if (len == 0) {
         if (state->indent) {
             ruby_xfree(state->indent);
             state->indent = NULL;
+            state->indent_len = 0;
         }
     } else {
         if (state->indent) ruby_xfree(state->indent);
         state->indent = strdup(RSTRING_PTR(indent));
+        state->indent_len = len;
     }
     return Qnil;
 }
@@ -1061,7 +1047,7 @@ static VALUE cState_indent_set(VALUE self, VALUE indent)
 static VALUE cState_space(VALUE self)
 {
     GET_STATE(self);
-    return state->space ? rb_str_new2(state->space) : rb_str_new2("");
+    return state->space ? rb_str_new(state->space, state->space_len) : rb_str_new2("");
 }
 
 /*
@@ -1072,16 +1058,20 @@ static VALUE cState_space(VALUE self)
  */
 static VALUE cState_space_set(VALUE self, VALUE space)
 {
+    unsigned long len;
     GET_STATE(self);
     Check_Type(space, T_STRING);
-    if (RSTRING_LEN(space) == 0) {
+    len = RSTRING_LEN(space);
+    if (len == 0) {
         if (state->space) {
             ruby_xfree(state->space);
             state->space = NULL;
+            state->space_len = 0;
         }
     } else {
         if (state->space) ruby_xfree(state->space);
         state->space = strdup(RSTRING_PTR(space));
+        state->space_len = len;
     }
     return Qnil;
 }
@@ -1094,7 +1084,7 @@ static VALUE cState_space_set(VALUE self, VALUE space)
 static VALUE cState_space_before(VALUE self)
 {
     GET_STATE(self);
-    return state->space_before ? rb_str_new2(state->space_before) : rb_str_new2("");
+    return state->space_before ? rb_str_new(state->space_before, state->space_before_len) : rb_str_new2("");
 }
 
 /*
@@ -1104,16 +1094,20 @@ static VALUE cState_space_before(VALUE self)
  */
 static VALUE cState_space_before_set(VALUE self, VALUE space_before)
 {
+    unsigned long len;
     GET_STATE(self);
     Check_Type(space_before, T_STRING);
-    if (RSTRING_LEN(space_before) == 0) {
+    len = RSTRING_LEN(space_before);
+    if (len == 0) {
         if (state->space_before) {
             ruby_xfree(state->space_before);
             state->space_before = NULL;
+            state->space_before_len = 0;
         }
     } else {
         if (state->space_before) ruby_xfree(state->space_before);
         state->space_before = strdup(RSTRING_PTR(space_before));
+        state->space_before_len = len;
     }
     return Qnil;
 }
@@ -1127,7 +1121,7 @@ static VALUE cState_space_before_set(VALUE self, VALUE space_before)
 static VALUE cState_object_nl(VALUE self)
 {
     GET_STATE(self);
-    return state->object_nl ? rb_str_new2(state->object_nl) : rb_str_new2("");
+    return state->object_nl ? rb_str_new(state->object_nl, state->object_nl_len) : rb_str_new2("");
 }
 
 /*
@@ -1138,9 +1132,11 @@ static VALUE cState_object_nl(VALUE self)
  */
 static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
 {
+    unsigned long len;
     GET_STATE(self);
     Check_Type(object_nl, T_STRING);
-    if (RSTRING_LEN(object_nl) == 0) {
+    len = RSTRING_LEN(object_nl);
+    if (len == 0) {
         if (state->object_nl) {
             ruby_xfree(state->object_nl);
             state->object_nl = NULL;
@@ -1148,6 +1144,7 @@ static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
     } else {
         if (state->object_nl) ruby_xfree(state->object_nl);
         state->object_nl = strdup(RSTRING_PTR(object_nl));
+        state->object_nl_len = len;
     }
     return Qnil;
 }
@@ -1160,7 +1157,7 @@ static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
 static VALUE cState_array_nl(VALUE self)
 {
     GET_STATE(self);
-    return state->array_nl ? rb_str_new2(state->array_nl) : rb_str_new2("");
+    return state->array_nl ? rb_str_new(state->array_nl, state->array_nl_len) : rb_str_new2("");
 }
 
 /*
@@ -1170,9 +1167,11 @@ static VALUE cState_array_nl(VALUE self)
  */
 static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
 {
+    unsigned long len;
     GET_STATE(self);
     Check_Type(array_nl, T_STRING);
-    if (RSTRING_LEN(array_nl) == 0) {
+    len = RSTRING_LEN(array_nl);
+    if (len == 0) {
         if (state->array_nl) {
             ruby_xfree(state->array_nl);
             state->array_nl = NULL;
@@ -1180,6 +1179,7 @@ static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
     } else {
         if (state->array_nl) ruby_xfree(state->array_nl);
         state->array_nl = strdup(RSTRING_PTR(array_nl));
+        state->array_nl_len = len;
     }
     return Qnil;
 }
@@ -1246,6 +1246,83 @@ static VALUE cState_ascii_only_p(VALUE self)
     return state->ascii_only ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq: quirks_mode?
+ *
+ * Returns true, if quirks mode is enabled. Otherwise returns false.
+ */
+static VALUE cState_quirks_mode_p(VALUE self)
+{
+    GET_STATE(self);
+    return state->quirks_mode ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq: quirks_mode=(enable)
+ *
+ * If set to true, enables the quirks_mode mode.
+ */
+static VALUE cState_quirks_mode_set(VALUE self, VALUE enable)
+{
+    GET_STATE(self);
+    state->quirks_mode = RTEST(enable);
+    return Qnil;
+}
+
+/*
+ * call-seq: depth
+ *
+ * This integer returns the current depth of data structure nesting.
+ */
+static VALUE cState_depth(VALUE self)
+{
+    GET_STATE(self);
+    return LONG2FIX(state->depth);
+}
+
+/*
+ * call-seq: depth=(depth)
+ *
+ * This sets the maximum level of data structure nesting in the generated JSON
+ * to the integer depth, max_nesting = 0 if no maximum should be checked.
+ */
+static VALUE cState_depth_set(VALUE self, VALUE depth)
+{
+    GET_STATE(self);
+    Check_Type(depth, T_FIXNUM);
+    state->depth = FIX2LONG(depth);
+    return Qnil;
+}
+
+/*
+ * call-seq: buffer_initial_length
+ *
+ * This integer returns the current inital length of the buffer.
+ */
+static VALUE cState_buffer_initial_length(VALUE self)
+{
+    GET_STATE(self);
+    return LONG2FIX(state->buffer_initial_length);
+}
+
+/*
+ * call-seq: buffer_initial_length=(length)
+ *
+ * This sets the initial length of the buffer to +length+, if +length+ > 0,
+ * otherwise its value isn't changed.
+ */
+static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_length)
+{
+    long initial_length;
+    GET_STATE(self);
+    Check_Type(buffer_initial_length, T_FIXNUM);
+    initial_length = FIX2LONG(buffer_initial_length);
+    if (initial_length > 0) {
+        state->buffer_initial_length = initial_length;
+    }
+    return Qnil;
+}
+
 /*
  *
  */
@@ -1280,11 +1357,20 @@ void Init_generator()
     rb_define_method(cState, "check_circular?", cState_check_circular_p, 0);
     rb_define_method(cState, "allow_nan?", cState_allow_nan_p, 0);
     rb_define_method(cState, "ascii_only?", cState_ascii_only_p, 0);
+    rb_define_method(cState, "quirks_mode?", cState_quirks_mode_p, 0);
+    rb_define_method(cState, "quirks_mode", cState_quirks_mode_p, 0);
+    rb_define_method(cState, "quirks_mode=", cState_quirks_mode_set, 1);
+    rb_define_method(cState, "depth", cState_depth, 0);
+    rb_define_method(cState, "depth=", cState_depth_set, 1);
+    rb_define_method(cState, "buffer_initial_length", cState_buffer_initial_length, 0);
+    rb_define_method(cState, "buffer_initial_length=", cState_buffer_initial_length_set, 1);
     rb_define_method(cState, "configure", cState_configure, 1);
+    rb_define_alias(cState, "merge", "configure");
     rb_define_method(cState, "to_h", cState_to_h, 0);
+    rb_define_alias(cState, "to_hash", "to_h");
     rb_define_method(cState, "[]", cState_aref, 1);
+    rb_define_method(cState, "[]=", cState_aset, 2);
     rb_define_method(cState, "generate", cState_generate, 1);
-    rb_define_method(cState, "partial_generate", cState_partial_generate, 1);
 
     mGeneratorMethods = rb_define_module_under(mGenerator, "GeneratorMethods");
     mObject = rb_define_module_under(mGeneratorMethods, "Object");
@@ -1293,8 +1379,10 @@ void Init_generator()
     rb_define_method(mHash, "to_json", mHash_to_json, -1);
     mArray = rb_define_module_under(mGeneratorMethods, "Array");
     rb_define_method(mArray, "to_json", mArray_to_json, -1);
-    mInteger = rb_define_module_under(mGeneratorMethods, "Integer");
-    rb_define_method(mInteger, "to_json", mInteger_to_json, -1);
+    mFixnum = rb_define_module_under(mGeneratorMethods, "Fixnum");
+    rb_define_method(mFixnum, "to_json", mFixnum_to_json, -1);
+    mBignum = rb_define_module_under(mGeneratorMethods, "Bignum");
+    rb_define_method(mBignum, "to_json", mBignum_to_json, -1);
     mFloat = rb_define_module_under(mGeneratorMethods, "Float");
     rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
     mString = rb_define_module_under(mGeneratorMethods, "String");
@@ -1323,6 +1411,9 @@ void Init_generator()
     i_max_nesting = rb_intern("max_nesting");
     i_allow_nan = rb_intern("allow_nan");
     i_ascii_only = rb_intern("ascii_only");
+    i_quirks_mode = rb_intern("quirks_mode");
+    i_depth = rb_intern("depth");
+    i_buffer_initial_length = rb_intern("buffer_initial_length");
     i_pack = rb_intern("pack");
     i_unpack = rb_intern("unpack");
     i_create_id = rb_intern("create_id");
@@ -1332,10 +1423,13 @@ void Init_generator()
     i_send = rb_intern("__send__");
     i_respond_to_p = rb_intern("respond_to?");
     i_match = rb_intern("match");
+    i_keys = rb_intern("keys");
+    i_dup = rb_intern("dup");
 #ifdef HAVE_RUBY_ENCODING_H
     CEncoding_UTF_8 = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-8"));
     i_encoding = rb_intern("encoding");
     i_encode = rb_intern("encode");
 #endif
+    i_SAFE_STATE_PROTOTYPE = rb_intern("SAFE_STATE_PROTOTYPE");
     CJSON_SAFE_STATE_PROTOTYPE = Qnil;
 }