oj 0.8.0 → 0.9.0

data/ext/oj/cache8.h

@@ -0,0 +1,46 @@
+/* cache8.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __OJ_CACHE8_H__
+#define __OJ_CACHE8_H__
+
+#include "ruby.h"
+
+typedef struct _Cache8  *Cache8;
+typedef unsigned long   slot_t;
+
+extern void     oj_cache8_new(Cache8 *cache);
+extern void     oj_cache8_delete(Cache8 cache);
+
+extern slot_t   oj_cache8_get(Cache8 cache, VALUE key, slot_t **slot);
+
+extern void     oj_cache8_print(Cache8 cache);
+
+#endif /* __OJ_CACHE8_H__ */

data/ext/oj/dump.c

@@ -41,35 +41,20 @@
 #include "st.h"
 #endif
 
-typedef unsigned long   ulong;
-
-typedef struct _Str {
-    const char  *str;
-    size_t      len;
-} *Str;
+#include "cache8.h"
 
-typedef struct _Element {
-    struct _Str         clas;
-    struct _Str         attr;
-    unsigned long       id;
-    int                 indent; // < 0 indicates no \n
-    int                 closed;
-    char                type;
-} *Element;
+typedef unsigned long   ulong;
 
 typedef struct _Out {
-    void                (*w_start)(struct _Out *out, Element e);
-    void                (*w_end)(struct _Out *out, Element e);
-    void                (*w_time)(struct _Out *out, VALUE obj);
-    char                *buf;
-    char                *end;
-    char                *cur;
-//    Cache8              circ_cache;
-//    unsigned long       circ_cnt;
-    int                 indent;
-    int                 depth; // used by dumpHash
-    Options             opts;
-    uint32_t		hash_cnt;
+    char	*buf;
+    char	*end;
+    char	*cur;
+    Cache8	circ_cache;
+    slot_t	circ_cnt;
+    int		indent;
+    int		depth; // used by dump_hash
+    Options	opts;
+    uint32_t	hash_cnt;
 } *Out;
 
 static void     dump_obj_to_json(VALUE obj, Options copts, Out out);
@@ -81,7 +66,7 @@ static void	dump_false(Out out);
 static void	dump_fixnum(VALUE obj, Out out);
 static void	dump_bignum(VALUE obj, Out out);
 static void	dump_float(VALUE obj, Out out);
-static void	dump_cstr(const char *str, size_t cnt, int is_sym, Out out);
+static void	dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out);
 static void	dump_hex(u_char c, Out out);
 static void	dump_str_comp(VALUE obj, Out out);
 static void	dump_str_obj(VALUE obj, Out out);
@@ -98,8 +83,10 @@ static void	dump_data_comp(VALUE obj, Out out);
 static void	dump_data_obj(VALUE obj, Out out);
 static void	dump_obj_comp(VALUE obj, int depth, Out out);
 static void	dump_obj_obj(VALUE obj, int depth, Out out);
+static void	dump_struct_comp(VALUE obj, int depth, Out out);
+static void	dump_struct_obj(VALUE obj, int depth, Out out);
 static int	dump_attr_cb(ID key, VALUE value, Out out);
-static void	dump_obj_attrs(VALUE obj, int with_class, int depth, Out out);
+static void	dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out);
 
 static void     grow(Out out, size_t len);
 static int      is_json_friendly(const u_char *str, size_t len);
@@ -154,6 +141,39 @@ fill_indent(Out out, int cnt) {
     }
 }
 
+inline static const char*
+ulong2str(uint32_t num, char *end) {
+    char        *b;
+
+    *end-- = '\0';
+    for (b = end; 0 < num || b == end; num /= 10, b--) {
+        *b = (num % 10) + '0';
+    }
+    b++;
+
+    return b;
+}
+
+inline static void
+dump_ulong(unsigned long num, Out out) {
+    char        buf[32];
+    char        *b = buf + sizeof(buf) - 1;
+
+    *b-- = '\0';
+    if (0 < num) {
+        for (; 0 < num; num /= 10, b--) {
+            *b = (num % 10) + '0';
+        }
+	b++;
+    } else {
+        *b = '0';
+    }
+    for (; '\0' != *b; b++) {
+        *out->cur++ = *b;
+    }
+    *out->cur = '\0';
+}
+
 static void
 grow(Out out, size_t len) {
     size_t  size = out->end - out->buf;
@@ -181,6 +201,34 @@ dump_hex(u_char c, Out out) {
     *out->cur++ = hex_chars[d];
 }
 
+// returns 0 if not using circular references, -1 if not further writing is
+// needed (duplicate), and a positive value if the object was added to the cache.
+static long
+check_circular(VALUE obj, Out out) {
+    slot_t	id = 0;
+    slot_t	*slot;
+
+    if (ObjectMode == out->opts->mode && Yes == out->opts->circular) {
+	if (0 == (id = oj_cache8_get(out->circ_cache, obj, &slot))) {
+	    out->circ_cnt++;
+	    id = out->circ_cnt;
+	    *slot = id;
+	} else {
+	    if (out->end - out->cur <= 18) {
+		grow(out, 18);
+	    }
+	    *out->cur++ = '"';
+	    *out->cur++ = '^';
+	    *out->cur++ = 'r';
+	    dump_ulong(id, out);
+	    *out->cur++ = '"';
+
+	    return -1;
+	}
+    }
+    return (long)id;
+}
+
 static void
 dump_nil(Out out) {
     size_t      size = 4;
@@ -286,15 +334,25 @@ dump_float(VALUE obj, Out out) {
 }
 
 static void
-dump_cstr(const char *str, size_t cnt, int is_sym, Out out) {
+dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out) {
     size_t	size = json_friendly_size((u_char*)str, cnt);
     
+    if (out->end - out->cur <= (long)size + 10) { // extra 10 for escaped first char, quotes, and sym
+	grow(out, size + 10);
+    }
+    *out->cur++ = '"';
+    if (escape1) {
+	*out->cur++ = '\\';
+	*out->cur++ = 'u';
+	*out->cur++ = '0';
+	*out->cur++ = '0';
+	dump_hex((u_char)*str, out);
+	cnt--;
+	size--;
+	str++;
+	is_sym = 0; // just to make sure
+    }
     if (cnt == size) {
-	cnt += 2 + is_sym;
-	if (out->end - out->cur <= (long)cnt) {
-	    grow(out, cnt);
-	}
-	*out->cur++ = '"';
 	if (is_sym) {
 	    *out->cur++ = ':';
 	}
@@ -303,11 +361,6 @@ dump_cstr(const char *str, size_t cnt, int is_sym, Out out) {
 	}
 	*out->cur++ = '"';
     } else {
-	size += 2;
-	if (out->end - out->cur <= (long)size) {
-	    grow(out, size);
-	}
-	*out->cur++ = '"';
 	if (is_sym) {
 	    *out->cur++ = ':';
 	}
@@ -352,37 +405,23 @@ dump_cstr(const char *str, size_t cnt, int is_sym, Out out) {
 
 static void
 dump_str_comp(VALUE obj, Out out) {
-    dump_cstr(StringValuePtr(obj), RSTRING_LEN(obj), 0, out);
+    dump_cstr(StringValuePtr(obj), RSTRING_LEN(obj), 0, 0, out);
 }
 
 static void
 dump_str_obj(VALUE obj, Out out) {
     const char	*s = StringValuePtr(obj);
     size_t	len = RSTRING_LEN(obj);
-    
-    if (':' == *s) {
-	if (out->end - out->cur <= 6) {
-	    grow(out, 6);
-	}
-	*out->cur++ = '{';
-	*out->cur++ = '"';
-	*out->cur++ = '^';
-	*out->cur++ = 's';
-	*out->cur++ = '"';
-	*out->cur++ = ':';
-	dump_cstr(s, len, 0, out);
-	*out->cur++ = '}';
-	*out->cur = '\0';
-    } else {
-	dump_cstr(s, len, 0, out);
-    }
+    char	s1 = s[1];
+
+    dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
 }
 
 static void
 dump_sym_comp(VALUE obj, Out out) {
     const char	*sym = rb_id2name(SYM2ID(obj));
     
-    dump_cstr(sym, strlen(sym), 0, out);
+    dump_cstr(sym, strlen(sym), 0, 0, out);
 }
 
 static void
@@ -390,29 +429,14 @@ dump_sym_obj(VALUE obj, Out out) {
     const char	*sym = rb_id2name(SYM2ID(obj));
     size_t	len = strlen(sym);
     
-    if (':' == *sym) {
-	if (out->end - out->cur <= 6) {
-	    grow(out, 6);
-	}
-	*out->cur++ = '{';
-	*out->cur++ = '"';
-	*out->cur++ = '^';
-	*out->cur++ = 'm';
-	*out->cur++ = '"';
-	*out->cur++ = ':';
-	dump_cstr(sym, len, 0, out);
-	*out->cur++ = '}';
-	*out->cur = '\0';
-    } else {
-	dump_cstr(sym, len, 1, out);
-    }
+    dump_cstr(sym, len, 1, 0, out);
 }
 
 static void
 dump_class_comp(VALUE obj, Out out) {
     const char	*s = rb_class2name(obj);
 
-    dump_cstr(s, strlen(s), 0, out);
+    dump_cstr(s, strlen(s), 0, 0, out);
 }
 
 static void
@@ -429,25 +453,47 @@ dump_class_obj(VALUE obj, Out out) {
     *out->cur++ = 'c';
     *out->cur++ = '"';
     *out->cur++ = ':';
-    dump_cstr(s, len, 0, out);
+    dump_cstr(s, len, 0, 0, out);
     *out->cur++ = '}';
     *out->cur = '\0';
 }
 
 static void
 dump_array(VALUE a, int depth, Out out) {
-    VALUE       *np = RARRAY_PTR(a);
-    size_t      size = 2;
-    int		cnt = (int)RARRAY_LEN(a);
+    VALUE	*np;
+    size_t	size;
+    int		cnt;
     int		d2 = depth + 1;
-    
+    long	id = check_circular(a, out);
+
+    if (id < 0) {
+	return;
+    }
+    np = RARRAY_PTR(a);
+    cnt = (int)RARRAY_LEN(a);
+    *out->cur++ = '[';
+    if (0 < id) {
+	size = d2 * out->indent + 16;
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	fill_indent(out, d2);
+	*out->cur++ = '"';
+	*out->cur++ = '^';
+	*out->cur++ = 'i';
+	dump_ulong(id, out);
+	*out->cur++ = '"';
+    }
+    size = 2;
     if (out->end - out->cur <= (long)size) {
         grow(out, size);
     }
-    *out->cur++ = '[';
     if (0 == cnt) {
 	*out->cur++ = ']';
     } else {
+	if (0 < id) {
+	    *out->cur++ = ',';
+	}
 	size = d2 * out->indent + 2;
 	for (; 0 < cnt; cnt--, np++) {
 	    if (out->end - out->cur <= (long)size) {
@@ -456,7 +502,6 @@ dump_array(VALUE a, int depth, Out out) {
 	    fill_indent(out, d2);
 	    dump_val(*np, d2, out);
 	    if (1 < cnt) {
-		// TBD check size?
 		*out->cur++ = ',';
 	    }
 	}
@@ -501,7 +546,6 @@ hash_cb_object(VALUE key, VALUE value, Out out) {
 	grow(out, size);
     }
     fill_indent(out, depth);
-    // TBD if key is a string else dump with unique key for and entry array
     if (rb_type(key) == T_STRING) {
 	dump_str_obj(key, out);
 	*out->cur++ = ':';
@@ -558,17 +602,35 @@ hash_cb_object(VALUE key, VALUE value, Out out) {
 
 static void
 dump_hash(VALUE obj, int depth, int mode, Out out) {
-    int	cnt = (int)RHASH_SIZE(obj);
+    int		cnt = (int)RHASH_SIZE(obj);
+    size_t	size = depth * out->indent + 2;
 
     if (out->end - out->cur <= 2) {
 	grow(out, 2);
     }
-    *out->cur++ = '{';
     if (0 == cnt) {
+	*out->cur++ = '{';
 	*out->cur++ = '}';
     } else {
-	size_t	size = depth * out->indent + 2;
+	long	id = check_circular(obj, out);
 
+	if (0 > id) {
+	    return;
+	}
+	*out->cur++ = '{';
+	if (0 < id) {
+	    if (out->end - out->cur <= (long)size + 16) {
+		grow(out, size + 16);
+	    }
+	    fill_indent(out, depth + 1);
+	    *out->cur++ = '"';
+	    *out->cur++ = '^';
+	    *out->cur++ = 'i';
+	    *out->cur++ = '"';
+	    *out->cur++ = ':';
+	    dump_ulong(id, out);
+	    *out->cur++ = ',';
+	}
 	out->depth = depth + 1;
 	if (ObjectMode == mode) {
 	    rb_hash_foreach(obj, hash_cb_object, (VALUE)out);
@@ -656,6 +718,13 @@ dump_obj_comp(VALUE obj, int depth, Out out) {
 	    rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
 	}
 	dump_hash(h, depth, out->opts->mode, out);
+    } else if (rb_respond_to(obj, oj_as_json_id)) {
+	VALUE	h = rb_funcall(obj, oj_as_json_id, 0);
+ 
+	if (T_HASH != rb_type(h)) {
+	    rb_raise(rb_eTypeError, "%s.as_json() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	}
+	dump_hash(h, depth, out->opts->mode, out);
     } else if (rb_respond_to(obj, oj_to_json_id)) {
 	VALUE		rs = rb_funcall(obj, oj_to_json_id, 0);
 	const char	*s = StringValuePtr(rs);
@@ -667,14 +736,18 @@ dump_obj_comp(VALUE obj, int depth, Out out) {
 	memcpy(out->cur, s, len);
 	out->cur += len;
     } else {
-	dump_obj_attrs(obj, 0, depth, out);
+	dump_obj_attrs(obj, 0, 0, depth, out);
     }
     *out->cur = '\0';
 }
 
 inline static void
 dump_obj_obj(VALUE obj, int depth, Out out) {
-    dump_obj_attrs(obj, 1, depth, out);
+    long	id = check_circular(obj, out);
+
+    if (0 <= id) {
+	dump_obj_attrs(obj, 1, id, depth, out);
+    }
 }
 
 static int
@@ -689,14 +762,14 @@ dump_attr_cb(ID key, VALUE value, Out out) {
     fill_indent(out, depth);
     if ('@' == *attr) {
 	attr++;
-	dump_cstr(attr, strlen(attr), 0, out);
+	dump_cstr(attr, strlen(attr), 0, 0, out);
     } else {
 	char	buf[32];
 
 	*buf = '~';
 	strncpy(buf + 1, attr, sizeof(buf) - 2);
 	buf[sizeof(buf) - 1] = '\0';
-	dump_cstr(buf, strlen(buf), 0, out);
+	dump_cstr(buf, strlen(buf), 0, 0, out);
     }
     *out->cur++ = ':';
     dump_val(value, depth, out);
@@ -707,7 +780,7 @@ dump_attr_cb(ID key, VALUE value, Out out) {
 }
 
 static void
-dump_obj_attrs(VALUE obj, int with_class, int depth, Out out) {
+dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out) {
     size_t	size;
     int		d2 = depth + 1;
 
@@ -729,7 +802,21 @@ dump_obj_attrs(VALUE obj, int with_class, int depth, Out out) {
 	*out->cur++ = 'o';
 	*out->cur++ = '"';
 	*out->cur++ = ':';
-	dump_cstr(class_name, clen, 0, out);
+	dump_cstr(class_name, clen, 0, 0, out);
+    }
+    if (0 < id) {
+	size = d2 * out->indent + 16;
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	*out->cur++ = ',';
+	fill_indent(out, d2);
+	*out->cur++ = '"';
+	*out->cur++ = '^';
+	*out->cur++ = 'i';
+	*out->cur++ = '"';
+	*out->cur++ = ':';
+	dump_ulong(id, out);
     }
     {
 	int	cnt;
@@ -763,14 +850,14 @@ dump_obj_attrs(VALUE obj, int with_class, int depth, Out out) {
 	    attr = rb_id2name(vid);
 	    if ('@' == *attr) {
 		attr++;
-		dump_cstr(attr, strlen(attr), 0, out);
+		dump_cstr(attr, strlen(attr), 0, 0, out);
 	    } else {
 		char	buf[32];
 
 		*buf = '~';
 		strncpy(buf + 1, attr, sizeof(buf) - 2);
 		buf[sizeof(buf) - 1] = '\0';
-		dump_cstr(buf, strlen(attr) + 1, 0, out);
+		dump_cstr(buf, strlen(attr) + 1, 0, 0, out);
 	    }
 	    *out->cur++ = ':';
 	    dump_val(rb_ivar_get(obj, vid), d2, out);
@@ -788,6 +875,73 @@ dump_obj_attrs(VALUE obj, int with_class, int depth, Out out) {
     *out->cur = '\0';
 }
 
+static void
+dump_struct_comp(VALUE obj, int depth, Out out) {
+    if (rb_respond_to(obj, oj_to_hash_id)) {
+	VALUE	h = rb_funcall(obj, oj_to_hash_id, 0);
+ 
+	if (T_HASH != rb_type(h)) {
+	    rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	}
+	dump_hash(h, depth, out->opts->mode, out);
+    } else if (rb_respond_to(obj, oj_to_json_id)) {
+	VALUE		rs = rb_funcall(obj, oj_to_json_id, 0);
+	const char	*s = StringValuePtr(rs);
+	int		len = (int)RSTRING_LEN(rs);
+
+	if (out->end - out->cur <= len) {
+	    grow(out, len);
+	}
+	memcpy(out->cur, s, len);
+	out->cur += len;
+    } else {
+	dump_struct_obj(obj, depth, out);
+    }
+}
+
+static void
+dump_struct_obj(VALUE obj, int depth, Out out) {
+    VALUE	clas = rb_obj_class(obj);
+    const char	*class_name = rb_class2name(clas);
+    VALUE	*vp;
+    int		i;
+    int		d2 = depth + 1;
+    int		d3 = d2 + 1;
+    size_t	len = strlen(class_name);
+    size_t	size = d2 * out->indent + d3 * out->indent + 10 + len;
+            
+    if (out->end - out->cur <= (long)size) {
+	grow(out, size);
+    }
+    *out->cur++ = '{';
+    fill_indent(out, d2);
+    *out->cur++ = '"';
+    *out->cur++ = '^';
+    *out->cur++ = 'u';
+    *out->cur++ = '"';
+    *out->cur++ = ':';
+    *out->cur++ = '[';
+    fill_indent(out, d3);
+    *out->cur++ = '"';
+    memcpy(out->cur, class_name, len);
+    out->cur += len;
+    *out->cur++ = '"';
+    *out->cur++ = ',';
+    size = d3 * out->indent + 2;
+    for (i = (int)RSTRUCT_LEN(obj), vp = RSTRUCT_PTR(obj); 0 < i; i--, vp++) {
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	fill_indent(out, d3);
+	dump_val(*vp, d3, out);
+	*out->cur++ = ',';
+    }
+    out->cur--;
+    *out->cur++ = ']';
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}
+
 static void
 raise_strict(VALUE obj) {
     rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.\n", rb_class2name(rb_obj_class(obj)));
@@ -850,6 +1004,14 @@ dump_val(VALUE obj, int depth, Out out) {
 	}
 	break;
     case T_STRUCT: // for Range
+	switch (out->opts->mode) {
+	case StrictMode:	raise_strict(obj);		break;
+	case NullMode:		dump_nil(out);			break;
+	case CompatMode:	dump_struct_comp(obj, depth, out);	break;
+	case ObjectMode:
+	default:		dump_struct_obj(obj, depth, out);	break;
+	}
+	break;
 #if (defined T_COMPLEX && defined RCOMPLEX)
     case T_COMPLEX:
 #endif
@@ -857,9 +1019,13 @@ dump_val(VALUE obj, int depth, Out out) {
     case T_RATIONAL:
 #endif
     case T_REGEXP:
-	// TBD
-	rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
-		 rb_class2name(rb_obj_class(obj)), rb_type(obj));
+	switch (out->opts->mode) {
+	case StrictMode:	raise_strict(obj);		break;
+	case NullMode:		dump_nil(out);			break;
+	case CompatMode:
+	case ObjectMode:
+	default:		dump_obj_comp(obj, depth, out);	break;
+	}
 	break;
     default:
 	rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
@@ -873,19 +1039,17 @@ dump_obj_to_json(VALUE obj, Options copts, Out out) {
     out->buf = (char*)malloc(65336);
     out->end = out->buf + 65325; // 1 less than end plus extra for possible errors
     out->cur = out->buf;
-//    out->circ_cache = 0;
-//    out->circ_cnt = 0;
+    out->circ_cnt = 0;
     out->opts = copts;
     out->hash_cnt = 0;
-/*    if (Yes == copts->circular) {
-        ox_cache8_new(&out->circ_cache);
-	}*/
+    if (Yes == copts->circular) {
+        oj_cache8_new(&out->circ_cache);
+    }
     out->indent = copts->indent;
     dump_val(obj, 0, out);
-    
-/*    if (Yes == copts->circular) {
-        ox_cache8_delete(out->circ_cache);
-	}*/
+    if (Yes == copts->circular) {
+        oj_cache8_delete(out->circ_cache);
+    }
 }
 
 char*