oj 2.0.0 → 3.0.0

data/ext/oj/fast.c

@@ -38,6 +38,7 @@
 #include <errno.h>
 
 #include "oj.h"
+#include "encode.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_XML	65536
@@ -146,23 +147,6 @@ next_non_white(ParseInfo pi) {
     }
 }
 
-inline static void
-next_white(ParseInfo pi) {
-    for (; 1; pi->s++) {
-	switch(*pi->s) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	case '\0':
-	    return;
-	default:
-	    break;
-	}
-    }
-}
-
 inline static char*
 ulong_fill(char *s, size_t num) {
     char	buf[32];
@@ -186,7 +170,7 @@ ulong_fill(char *s, size_t num) {
 inline static void
 leaf_init(Leaf leaf, int type) {
     leaf->next = 0;
-    leaf->type = type;
+    leaf->rtype = type;
     leaf->parent_type = T_NONE;
     switch (type) {
     case T_ARRAY:
@@ -222,6 +206,8 @@ leaf_new(Doc doc, int type) {
     if (0 == doc->batches || BATCH_SIZE == doc->batches->next_avail) {
 	Batch	b = ALLOC(struct _Batch);
 
+	// Initializes all leaves with a NO_VAL value_type
+	memset(b, 0, sizeof(struct _Batch));
 	b->next = doc->batches;
 	doc->batches = b;
 	b->next_avail = 0;
@@ -248,7 +234,7 @@ leaf_append_element(Leaf parent, Leaf element) {
 static VALUE
 leaf_value(Doc doc, Leaf leaf) {
     if (RUBY_VAL != leaf->value_type) {
-	switch (leaf->type) {
+	switch (leaf->rtype) {
 	case T_NIL:
 	    leaf->value = Qnil;
 	    break;
@@ -266,9 +252,7 @@ leaf_value(Doc doc, Leaf leaf) {
 	    break;
 	case T_STRING:
 	    leaf->value = rb_str_new2(leaf->str);
-#if HAS_ENCODING_SUPPORT
-	    rb_enc_associate(leaf->value, oj_utf8_encoding);
-#endif
+	    leaf->value = oj_encode(leaf->value);
 	    leaf->value_type = RUBY_VAL;
 	    break;
 	case T_ARRAY:
@@ -278,7 +262,7 @@ leaf_value(Doc doc, Leaf leaf) {
 	    return leaf_hash_value(doc, leaf);
 	    break;
 	default:
-	    rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->type);
+	    rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype);
 	    break;
 	}
     }
@@ -361,84 +345,16 @@ leaf_fixnum_value(Leaf leaf) {
 	if (neg) {
 	    n = -n;
 	}
-	leaf->value = LONG2NUM(n);
+	leaf->value = rb_ll2inum(n);
     }
     leaf->value_type = RUBY_VAL;
 }
 
-#ifdef JRUBY_RUBY
-static void
-leaf_float_value(Leaf leaf) {
-    char	*s = leaf->str;
-    int64_t	n = 0;
-    long	a = 0;
-    long	div = 1;
-    long	e = 0;
-    int		neg = 0;
-    int		eneg = 0;
-    int		big = 0;
-
-    if ('-' == *s) {
-	s++;
-	neg = 1;
-    } else if ('+' == *s) {
-	s++;
-    }
-    for (; '0' <= *s && *s <= '9'; s++) {
-	n = n * 10 + (*s - '0');
-	if (NUM_MAX <= n) {
-	    big = 1;
-	}
-    }
-    if (big) {
-	char	c = *s;
-	
-	*s = '\0';
-	leaf->value = rb_cstr_to_inum(leaf->str, 10, 0);
-	*s = c;
-    } else {
-	double	d;
-
-	if ('.' == *s) {
-	    s++;
-	    for (; '0' <= *s && *s <= '9'; s++) {
-		a = a * 10 + (*s - '0');
-		div *= 10;
-	    }
-	}
-	if ('e' == *s || 'E' == *s) {
-	    s++;
-	    if ('-' == *s) {
-		s++;
-		eneg = 1;
-	    } else if ('+' == *s) {
-		s++;
-	    }
-	    for (; '0' <= *s && *s <= '9'; s++) {
-		e = e * 10 + (*s - '0');
-	    }
-	}
-	d = (double)n + (double)a / (double)div;
-	if (neg) {
-	    d = -d;
-	}
-	if (0 != e) {
-	    if (eneg) {
-		e = -e;
-	    }
-	    d *= pow(10.0, e);
-	}
-	leaf->value = rb_float_new(d);
-    }
-    leaf->value_type = RUBY_VAL;
-}
-#else
 static void
 leaf_float_value(Leaf leaf) {
     leaf->value = rb_float_new(rb_cstr_to_dbl(leaf->str, 1));
     leaf->value_type = RUBY_VAL;
 }
-#endif
 
 static VALUE
 leaf_array_value(Doc doc, Leaf leaf) {
@@ -467,9 +383,7 @@ leaf_hash_value(Doc doc, Leaf leaf) {
 
 	do {
 	    key = rb_str_new2(e->key);
-#if HAS_ENCODING_SUPPORT
-	    rb_enc_associate(key, oj_utf8_encoding);
-#endif
+	    key = oj_encode(key);
 	    rb_hash_aset(h, key, leaf_value(doc, e));
 	    e = e->next;
 	} while (e != first);
@@ -695,33 +609,59 @@ read_nil(ParseInfo pi) {
     return leaf;
 }
 
-static char
-read_hex(ParseInfo pi, char *h) {
-    uint8_t	b = 0;
+static uint32_t
+read_4hex(ParseInfo pi, const char *h) {
+    uint32_t	b = 0;
+    int		i;
+
+    for (i = 0; i < 4; i++, h++) {
+	b = b << 4;
+	if ('0' <= *h && *h <= '9') {
+	    b += *h - '0';
+	} else if ('A' <= *h && *h <= 'F') {
+	    b += *h - 'A' + 10;
+	} else if ('a' <= *h && *h <= 'f') {
+	    b += *h - 'a' + 10;
+	} else {
+	    raise_error("invalid hex character", pi->str, pi->s);
+	}
+    }
+    return b;
+}
 
-    if ('0' <= *h && *h <= '9') {
-	b = *h - '0';
-    } else if ('A' <= *h && *h <= 'F') {
-	b = *h - 'A' + 10;
-    } else if ('a' <= *h && *h <= 'f') {
-	b = *h - 'a' + 10;
-    } else {
-	pi->s = h;
-	raise_error("invalid hex character", pi->str, pi->s);
-    }
-    h++;
-    b = b << 4;
-    if ('0' <= *h && *h <= '9') {
-	b += *h - '0';
-    } else if ('A' <= *h && *h <= 'F') {
-	b += *h - 'A' + 10;
-    } else if ('a' <= *h && *h <= 'f') {
-	b += *h - 'a' + 10;
+static char*
+unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
+    if (0x0000007F >= code) {
+	*t++ = (char)code;
+    } else if (0x000007FF >= code) {
+	*t++ = 0xC0 | (code >> 6);
+	*t++ = 0x80 | (0x3F & code);
+    } else if (0x0000FFFF >= code) {
+	*t++ = 0xE0 | (code >> 12);
+	*t++ = 0x80 | ((code >> 6) & 0x3F);
+	*t++ = 0x80 | (0x3F & code);
+    } else if (0x001FFFFF >= code) {
+	*t++ = 0xF0 | (code >> 18);
+	*t++ = 0x80 | ((code >> 12) & 0x3F);
+	*t++ = 0x80 | ((code >> 6) & 0x3F);
+	*t++ = 0x80 | (0x3F & code);
+    } else if (0x03FFFFFF >= code) {
+	*t++ = 0xF8 | (code >> 24);
+	*t++ = 0x80 | ((code >> 18) & 0x3F);
+	*t++ = 0x80 | ((code >> 12) & 0x3F);
+	*t++ = 0x80 | ((code >> 6) & 0x3F);
+	*t++ = 0x80 | (0x3F & code);
+    } else if (0x7FFFFFFF >= code) {
+	*t++ = 0xFC | (code >> 30);
+	*t++ = 0x80 | ((code >> 24) & 0x3F);
+	*t++ = 0x80 | ((code >> 18) & 0x3F);
+	*t++ = 0x80 | ((code >> 12) & 0x3F);
+	*t++ = 0x80 | ((code >> 6) & 0x3F);
+	*t++ = 0x80 | (0x3F & code);
     } else {
-	pi->s = h;
-	raise_error("invalid hex character", pi->str, pi->s);
+	raise_error("invalid Unicode character", pi->str, pi->s);
     }
-    return (char)b;
+    return t;
 }
 
 /* Assume the value starts immediately and goes until the quote character is
@@ -751,16 +691,31 @@ read_quoted_value(ParseInfo pi) {
 	    case '"':	*t = '"';	break;
 	    case '/':	*t = '/';	break;
 	    case '\\':	*t = '\\';	break;
-	    case 'u':
+	    case 'u': {
+		uint32_t	code;
+
 		h++;
-		*t = read_hex(pi, h);
-		h += 2;
-		if ('\0' != *t) {
-		    t++;
+		code = read_4hex(pi, h);
+		h += 3;
+		if (0x0000D800 <= code && code <= 0x0000DFFF) {
+		    uint32_t	c1 = (code - 0x0000D800) & 0x000003FF;
+		    uint32_t	c2;
+
+		    h++;
+		    if ('\\' != *h || 'u' != *(h + 1)) {
+			pi->s = h;
+			raise_error("invalid escaped character", pi->str, pi->s);
+		    }
+		    h += 2;
+		    c2 = read_4hex(pi, h);
+		    h += 3;
+		    c2 = (c2 - 0x0000DC00) & 0x000003FF;
+		    code = ((c1 << 10) | c2) + 0x00010000;
 		}
-		*t = read_hex(pi, h);
-		h++;
+		t = unicode_to_chars(pi, t, code);
+		t--;
 		break;
+	    }
 	    default:
 		pi->s = h;
 		raise_error("invalid escaped character", pi->str, pi->s);
@@ -779,15 +734,10 @@ read_quoted_value(ParseInfo pi) {
 // doc support functions
 inline static void
 doc_init(Doc doc) {
+    memset(doc, 0, sizeof(struct _Doc));
     doc->where = doc->where_path;
-    *doc->where = 0;
-    doc->data = 0;
     doc->self = Qundef;
-    doc->size = 0;
-    doc->json = 0;
     doc->batches = &doc->batch0;
-    doc->batch0.next = 0;
-    doc->batch0.next_avail = 0;
 }
 
 static void
@@ -863,7 +813,11 @@ parse_json(VALUE clas, char *json, int given, int allocated) {
     }
 #endif
     // last arg is free func void* func(void*)
+#if HAS_DATA_OBJECT_WRAP
+    doc->self = rb_data_object_wrap(clas, doc, 0, free_doc_cb);
+#else
     doc->self = rb_data_object_alloc(clas, doc, 0, free_doc_cb);
+#endif
     rb_gc_register_address(&doc->self);
     doc->json = json;
     DATA_PTR(doc->self) = doc;
@@ -902,7 +856,10 @@ get_doc_leaf(Doc doc, const char *path) {
 	} else {
 	    size_t	cnt = doc->where - doc->where_path;
 
-	    memcpy(stack, doc->where_path, sizeof(Leaf) * cnt);
+	    if (MAX_STACK <= cnt) {
+		rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
+	    }
+	    memcpy(stack, doc->where_path, sizeof(Leaf) * (cnt + 1));
 	    lp = stack + cnt;
 	}
 	return get_leaf(stack, lp, path);
@@ -910,6 +867,35 @@ get_doc_leaf(Doc doc, const char *path) {
     return leaf;
 }
 
+static const char*
+next_slash(const char *s) {
+    for (; '\0' != *s; s++) {
+	if ('\\' == *s) {
+	    s++;
+	    if ('\0' == *s) {
+		break;
+	    }
+	} else if ('/' == *s) {
+	    return s;
+	}
+    }
+    return NULL;
+}
+
+static bool
+key_match(const char *pat, const char *key, int plen) {
+    for (; 0 < plen; plen--, pat++, key++) {
+	if ('\\' == *pat) {
+	    plen--;
+	    pat++;
+	}
+	if (*pat != *key) {
+	    return false;
+	}
+    }
+    return '\0' == *key;
+}
+
 static Leaf
 get_leaf(Leaf *stack, Leaf *lp, const char *path) {
     Leaf	leaf = *lp;
@@ -931,7 +917,7 @@ get_leaf(Leaf *stack, Leaf *lp, const char *path) {
 	} else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
 	    Leaf	first = leaf->elements->next;
 	    Leaf	e = first;
-	    int		type = leaf->type;
+	    int		type = leaf->rtype;
 
 	    leaf = 0;
 	    if (T_ARRAY == type) {
@@ -955,7 +941,7 @@ get_leaf(Leaf *stack, Leaf *lp, const char *path) {
 		} while (e != first);
 	    } else if (T_HASH == type) {
 		const char	*key = path;
-		const char	*slash = strchr(path, '/');
+		const char	*slash = next_slash(path);
 		int		klen;
 
 		if (0 == slash) {
@@ -966,7 +952,7 @@ get_leaf(Leaf *stack, Leaf *lp, const char *path) {
 		    path += klen + 1;
 		}
 		do {
-		    if (0 == strncmp(key, e->key, klen) && '\0' == e->key[klen]) {
+		    if (key_match(key, e->key, klen)) {
 			lp++;
 			*lp = e;
 			leaf = get_leaf(stack, lp, path);
@@ -988,11 +974,15 @@ each_leaf(Doc doc, VALUE self) {
 	    Leaf	e = first;
 
 	    doc->where++;
+	    if (MAX_STACK <= doc->where - doc->where_path) {
+		rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
+	    }
 	    do {
 		*doc->where = e;
 		each_leaf(doc, self);
 		e = e->next;
 	    } while (e != first);
+	    doc->where--;
 	}
     } else {
 	rb_yield(self);
@@ -1034,7 +1024,7 @@ move_step(Doc doc, const char *path, int loc) {
 	    Leaf	first = leaf->elements->next;
 	    Leaf	e = first;
 
-	    if (T_ARRAY == leaf->type) {
+	    if (T_ARRAY == leaf->rtype) {
 		int	cnt = 0;
 
 		for (; '0' <= *path && *path <= '9'; path++) {
@@ -1059,9 +1049,9 @@ move_step(Doc doc, const char *path, int loc) {
 		    cnt--;
 		    e = e->next;
 		} while (e != first);
-	    } else if (T_HASH == leaf->type) {
+	    } else if (T_HASH == leaf->rtype) {
 		const char	*key = path;
-		const char	*slash = strchr(path, '/');
+		const char	*slash = next_slash(path);
 		int		klen;
 
 		if (0 == slash) {
@@ -1072,7 +1062,7 @@ move_step(Doc doc, const char *path, int loc) {
 		    path += klen + 1;
 		}
 		do {
-		    if (0 == strncmp(key, e->key, klen) && '\0' == e->key[klen]) {
+		    if (key_match(key, e->key, klen)) {
 			doc->where++;
 			*doc->where = e;
 			loc = move_step(doc, path, loc + 1);
@@ -1109,14 +1099,14 @@ each_value(Doc doc, Leaf leaf) {
 
 // doc functions
 
-/* call-seq: open(json) { |doc| ... } => Object
+/* @overload open(json) { |doc| ... } => Object
  *
  * Parses a JSON document String and then yields to the provided block if one
  * is given with an instance of the Oj::Doc as the single yield parameter. If
  * a block is not given then an Oj::Doc instance is returned and must be
  * closed with a call to the #close() method when no longer needed.
  *
- * @param [String] json JSON document string
+ *   @param [String] json JSON document string
  * @yieldparam [Oj::Doc] doc parsed JSON document
  * @yieldreturn [Object] returns the result of the yield as the result of the method call
  * @example
@@ -1150,14 +1140,14 @@ doc_open(VALUE clas, VALUE str) {
     return obj;
 }
 
-/* call-seq: open_file(filename) { |doc| ... } => Object
+/* @overload open_file(filename) { |doc| ... } => Object
  *
  * Parses a JSON document from a file and then yields to the provided block if
  * one is given with an instance of the Oj::Doc as the single yield
  * parameter. If a block is not given then an Oj::Doc instance is returned and
  * must be closed with a call to the #close() method when no longer needed.
  *
- * @param [String] filename name of file that contains a JSON document
+ *   @param [String] filename name of file that contains a JSON document
  * @yieldparam [Oj::Doc] doc parsed JSON document
  * @yieldreturn [Object] returns the result of the yield as the result of the method call
  * @example
@@ -1206,11 +1196,34 @@ doc_open_file(VALUE clas, VALUE filename) {
     return obj;
 }
 
+static int
+esc_strlen(const char *s) {
+    int	cnt = 0;
+
+    for (; '\0' != *s; s++, cnt++) {
+	if ('/' == *s) {
+	    cnt++;
+	}
+    }
+    return cnt;
+}
+
+static char*
+append_key(char *p, const char *key) {
+    for (; '\0' != *key; p++, key++) {
+	if ('/' == *key) {
+	    *p++ = '\\';
+	}
+	*p = *key;
+    }
+    return p;
+}
+
 /* Document-method: parse
  * @see Oj::Doc.open
  */
 
-/* call-seq: where?() => String
+/* @overload where?() => String
  *
  * Returns a String that describes the absolute path to the current location
  * in the JSON document.
@@ -1231,7 +1244,7 @@ doc_where(VALUE self) {
 	for (lp = doc->where_path; lp <= doc->where; lp++) {
 	    leaf = *lp;
 	    if (T_HASH == leaf->parent_type) {
-		size += strlen((*lp)->key) + 1;
+		size += esc_strlen((*lp)->key) + 1;
 	    } else if (T_ARRAY == leaf->parent_type) {
 		size += ((*lp)->index < 100) ? 3 : 11;
 	    }
@@ -1241,7 +1254,7 @@ doc_where(VALUE self) {
 	for (lp = doc->where_path; lp <= doc->where; lp++) {
 	    leaf = *lp;
 	    if (T_HASH == leaf->parent_type) {
-		p = stpcpy(p, (*lp)->key);
+		p = append_key(p, (*lp)->key);
 	    } else if (T_ARRAY == leaf->parent_type) {
 		p = ulong_fill(p, (*lp)->index);
 	    }
@@ -1252,7 +1265,7 @@ doc_where(VALUE self) {
     }
 }
 
-/* call-seq: local_key() => String, Fixnum, nil
+/* @overload local_key() => String, Fixnum, nil
  *
  * Returns the final key to the current location.
  * @example
@@ -1268,16 +1281,14 @@ doc_local_key(VALUE self) {
 
     if (T_HASH == leaf->parent_type) {
 	key = rb_str_new2(leaf->key);
-#if HAS_ENCODING_SUPPORT
-	rb_enc_associate(key, oj_utf8_encoding);
-#endif
+	key = oj_encode(key);
     } else if (T_ARRAY == leaf->parent_type) {
 	key = LONG2NUM(leaf->index);
     }
     return key;
 }
 
-/* call-seq: home() => nil
+/* @overload home() => nil
  *
  * Moves the document marker or location to the hoot or home position. The
  * same operation can be performed with a Oj::Doc.move('/').
@@ -1294,13 +1305,13 @@ doc_home(VALUE self) {
     return oj_slash_string;
 }
 
-/* call-seq: type(path=nil) => Class
+/* @overload type(path=nil) => Class
  *
  * Returns the Class of the data value at the location identified by the path
  * or the current location if the path is nil or not provided. This method
  * does not create the Ruby Object at the location specified so the overhead
  * is low.
- * @param [String] path path to the location to get the type of if provided
+ *   @param [String] path path to the location to get the type of if provided
  * @example
  *   Oj::Doc.open('[1,2]') { |doc| doc.type() }	     #=> Array
  *   Oj::Doc.open('[1,2]') { |doc| doc.type('/1') }  #=> Fixnum
@@ -1317,12 +1328,16 @@ doc_type(int argc, VALUE *argv, VALUE self) {
 	path = StringValuePtr(*argv);
     }
     if (0 != (leaf = get_doc_leaf(doc, path))) {
-	switch (leaf->type) {
+	switch (leaf->rtype) {
 	case T_NIL:	type = rb_cNilClass;	break;
 	case T_TRUE:	type = rb_cTrueClass;	break;
 	case T_FALSE:	type = rb_cFalseClass;	break;
 	case T_STRING:	type = rb_cString;	break;
+#ifdef RUBY_INTEGER_UNIFICATION
+	case T_FIXNUM:	type = rb_cInteger;	break;
+#else
 	case T_FIXNUM:	type = rb_cFixnum;	break;
+#endif
 	case T_FLOAT:	type = rb_cFloat;	break;
 	case T_ARRAY:	type = rb_cArray;	break;
 	case T_HASH:	type = rb_cHash;	break;
@@ -1332,14 +1347,14 @@ doc_type(int argc, VALUE *argv, VALUE self) {
     return type;
 }
 
-/* call-seq: fetch(path=nil) => nil, true, false, Fixnum, Float, String, Array, Hash
+/* @overload fetch(path=nil) => nil, true, false, Fixnum, Float, String, Array, Hash
  *
  * Returns the value at the location identified by the path or the current
  * location if the path is nil or not provided. This method will create and
  * return an Array or Hash if that is the type of Object at the location
  * specified. This is more expensive than navigating to the leaves of the JSON
  * document.
- * @param [String] path path to the location to get the type of if provided
+ *   @param [String] path path to the location to get the type of if provided
  * @example
  *   Oj::Doc.open('[1,2]') { |doc| doc.fetch() }      #=> [1, 2]
  *   Oj::Doc.open('[1,2]') { |doc| doc.fetch('/1') }  #=> 1
@@ -1365,12 +1380,12 @@ doc_fetch(int argc, VALUE *argv, VALUE self) {
     return val;
 }
 
-/* call-seq: each_leaf(path=nil) => nil
+/* @overload each_leaf(path=nil) => nil
  *
  * Yields to the provided block for each leaf node with the identified
  * location of the JSON document as the root. The parameter passed to the
  * block on yield is the Doc instance after moving to the child location.
- * @param [String] path if provided it identified the top of the branch to process the leaves of
+ *   @param [String] path if provided it identified the top of the branch to process the leaves of
  * @yieldparam [Doc] Doc at the child location
  * @example
  *   Oj::Doc.open('[3,[2,1]]') { |doc|
@@ -1390,7 +1405,7 @@ doc_each_leaf(int argc, VALUE *argv, VALUE self) {
 
 	wlen = doc->where - doc->where_path;
 	if (0 < wlen) {
-	    memcpy(save_path, doc->where_path, sizeof(Leaf) * wlen);
+	    memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
 	}
 	if (1 <= argc) {
 	    Check_Type(*argv, T_STRING);
@@ -1401,24 +1416,24 @@ doc_each_leaf(int argc, VALUE *argv, VALUE self) {
 	    }
 	    if (0 != move_step(doc, path, 1)) {
 		if (0 < wlen) {
-		    memcpy(doc->where_path, save_path, sizeof(Leaf) * wlen);
+		    memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
 		}
 		return Qnil;
 	    }
 	}
 	each_leaf(doc, self);
 	if (0 < wlen) {
-	    memcpy(doc->where_path, save_path, sizeof(Leaf) * wlen);
+	    memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
 	}
     }
     return Qnil;
 }
 
-/* call-seq: move(path) => nil
+/* @overload move(path) => nil
  *
  * Moves the document marker to the path specified. The path can an absolute
  * path or a relative path.
- * @param [String] path path to the location to move to
+ *   @param [String] path path to the location to move to
  * @example
  *   Oj::Doc.open('{"one":[1,2]') { |doc| doc.move('/one/2'); doc.where? }  #=> "/one/2"
  */
@@ -1440,13 +1455,13 @@ doc_move(VALUE self, VALUE str) {
     return Qnil;
 }
 
-/* call-seq: each_child(path=nil) { |doc| ... } => nil
+/* @overload each_child(path=nil) { |doc| ... } => nil
  *
  * Yields to the provided block for each immediate child node with the
  * identified location of the JSON document as the root. The parameter passed
  * to the block on yield is the Doc instance after moving to the child
  * location.
- * @param [String] path if provided it identified the top of the branch to process the chilren of
+ *   @param [String] path if provided it identified the top of the branch to process the chilren of
  * @yieldparam [Doc] Doc at the child location
  * @example
  *   Oj::Doc.open('[3,[2,1]]') { |doc|
@@ -1466,7 +1481,7 @@ doc_each_child(int argc, VALUE *argv, VALUE self) {
 
 	wlen = doc->where - doc->where_path;
 	if (0 < wlen) {
-	    memcpy(save_path, doc->where_path, sizeof(Leaf) * wlen);
+	    memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
 	}
 	if (1 <= argc) {
 	    Check_Type(*argv, T_STRING);
@@ -1477,7 +1492,7 @@ doc_each_child(int argc, VALUE *argv, VALUE self) {
 	    }
 	    if (0 != move_step(doc, path, 1)) {
 		if (0 < wlen) {
-		    memcpy(doc->where_path, save_path, sizeof(Leaf) * wlen);
+		    memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
 		}
 		return Qnil;
 	    }
@@ -1494,19 +1509,19 @@ doc_each_child(int argc, VALUE *argv, VALUE self) {
 	    } while (e != first);
 	}
 	if (0 < wlen) {
-	    memcpy(doc->where_path, save_path, sizeof(Leaf) * wlen);
+	    memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
 	}
     }
     return Qnil;
 }
 
-/* call-seq: each_value(path=nil) { |val| ... } => nil
+/* @overload each_value(path=nil) { |val| ... } => nil
  *
  * Yields to the provided block for each leaf value in the identified location
  * of the JSON document. The parameter passed to the block on yield is the
  * value of the leaf. Only those leaves below the element specified by the
  * path parameter are processed.
- * @param [String] path if provided it identified the top of the branch to process the leaf values of
+ *   @param [String] path if provided it identified the top of the branch to process the leaf values of
  * @yieldparam [Object] val each leaf value
  * @example
  *   Oj::Doc.open('[3,[2,1]]') { |doc|
@@ -1541,12 +1556,12 @@ doc_each_value(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
-/* call-seq: dump(path=nil) => String
+/* @overload dump(path, filename)
  *
  * Dumps the document or nodes to a new JSON document. It uses the default
  * options for generating the JSON.
- * @param [String] path if provided it identified the top of the branch to dump to JSON
- * @param [String] filename if provided it is the filename to write the output to
+ *   @param path [String] if provided it identified the top of the branch to dump to JSON
+ *   @param filename [String] if provided it is the filename to write the output to
  * @example
  *   Oj::Doc.open('[3,[2,1]]') { |doc|
  *       doc.dump('/2')
@@ -1571,13 +1586,21 @@ doc_dump(int argc, VALUE *argv, VALUE self) {
 	}
     }
     if (0 != (leaf = get_doc_leaf(doc, path))) {
-	char	*json;
 	VALUE	rjson;
 
 	if (0 == filename) {
-	    json = oj_write_leaf_to_str(leaf, &oj_default_options);
-	    rjson = rb_str_new2(json);
-	    xfree(json);
+	    char	buf[4096];
+	    struct _Out out;
+
+	    out.buf = buf;
+	    out.end = buf + sizeof(buf) - 10;
+	    out.allocated = 0;
+	    out.omit_nil = oj_default_options.dump_opts.omit_nil;
+	    oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
+	    rjson = rb_str_new2(out.buf);
+	    if (out.allocated) {
+		xfree(out.buf);
+	    }
 	} else {
 	    oj_write_leaf_to_file(leaf, filename, &oj_default_options);
 	    rjson = Qnil;
@@ -1587,7 +1610,7 @@ doc_dump(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
-/* call-seq: size() => Fixnum
+/* @overload size() => Fixnum
  *
  * Returns the number of nodes in the JSON document where a node is any one of
  * the basic JSON components.
@@ -1600,7 +1623,7 @@ doc_size(VALUE self) {
     return ULONG2NUM(((Doc)DATA_PTR(self))->size);
 }
 
-/* call-seq: close() => nil
+/* @overload close() => nil
  *
  * Closes an open document. No further calls to the document will be valid
  * after closing.
@@ -1618,6 +1641,7 @@ doc_close(VALUE self) {
     if (0 != doc) {
 	xfree(doc->json);
 	doc_free(doc);
+	xfree(doc);
     }
     return Qnil;
 }
@@ -1626,6 +1650,12 @@ doc_close(VALUE self) {
 Oj = rb_define_module("Oj");
 #endif
 
+static VALUE
+doc_not_implemented(VALUE self) {
+    rb_raise(rb_eNotImpError, "Not implemented.");
+    return Qnil;
+}
+
 /* Document-class: Oj::Doc
  *
  * The Doc class is used to parse and navigate a JSON document. The model it
@@ -1690,4 +1720,7 @@ oj_init_doc() {
     rb_define_method(oj_doc_class, "dump", doc_dump, -1);
     rb_define_method(oj_doc_class, "size", doc_size, 0);
     rb_define_method(oj_doc_class, "close", doc_close, 0);
+
+    rb_define_method(oj_doc_class, "clone", doc_not_implemented, 0);
+    rb_define_method(oj_doc_class, "dup", doc_not_implemented, 0);
 }