oj 0.8.0 → 0.9.0

data/ext/oj/load.c

@@ -40,9 +40,17 @@ enum {
     TIME_HINT = 0x0100,
 };
 
+typedef struct _CircArray {
+    VALUE               obj_array[1024];
+    VALUE               *objs;
+    unsigned long       size; // allocated size or initial array size
+    unsigned long       cnt;
+} *CircArray;
+
 typedef struct _ParseInfo {
     char	*str;		/* buffer being read from */
     char	*s;		/* current position in buffer */
+    CircArray	circ_array;
 #ifdef HAVE_RUBY_ENCODING_H
     rb_encoding	*encoding;
 #else
@@ -51,10 +59,15 @@ typedef struct _ParseInfo {
     Options	options;
 } *ParseInfo;
 
+static CircArray	circ_array_new(void);
+static void		circ_array_free(CircArray ca);
+static void		circ_array_set(CircArray ca, VALUE obj, unsigned long id);
+static VALUE		circ_array_get(CircArray ca, unsigned long id);
+
 static VALUE	classname2class(const char *name, ParseInfo pi);
 static VALUE	read_next(ParseInfo pi, int hint);
 static VALUE	read_obj(ParseInfo pi);
-static VALUE	read_array(ParseInfo pi);
+static VALUE	read_array(ParseInfo pi, int hint);
 static VALUE	read_str(ParseInfo pi, int hint);
 static VALUE	read_num(ParseInfo pi);
 static VALUE	read_time(ParseInfo pi);
@@ -170,29 +183,94 @@ classname2class(const char *name, ParseInfo pi) {
     return clas;
 }
 
-VALUE
-oj_parse(char *json, Options options) {
-    VALUE		obj;
-    struct _ParseInfo	pi;
+#ifndef NO_RSTRUCT
+inline static VALUE
+structname2obj(const char *name) {
+    VALUE       ost;
 
-    if (0 == json) {
-	raise_error("Invalid arg, xml string can not be null", json, 0);
-    }
-    /* initialize parse info */
-    pi.str = json;
-    pi.s = json;
+    ost = rb_const_get(oj_struct_class, rb_intern(name));
+// use encoding as the indicator for Ruby 1.8.7 or 1.9.x
 #ifdef HAVE_RUBY_ENCODING_H
-    pi.encoding = ('\0' == *options->encoding) ? 0 : rb_enc_find(options->encoding);
+    return rb_struct_alloc_noinit(ost);
 #else
-    pi.encoding = 0;
+    return rb_struct_new(ost);
 #endif
-    pi.options = options;
-    if (Qundef == (obj = read_next(&pi, 0))) {
-	raise_error("no object read", pi.str, pi.s);
+}
+#endif
+
+inline static unsigned long
+read_ulong(const char *s, ParseInfo pi) {
+    unsigned long	n = 0;
+
+    for (; '\0' != *s; s++) {
+	if ('0' <= *s && *s <= '9') {
+	    n = n * 10 + (*s - '0');
+	} else {
+	    raise_error("Not a valid ID number", pi->str, pi->s);
+	}
     }
-    next_non_white(&pi);	// skip white space
-    if ('\0' != *pi.s) {
-	raise_error("invalid format, extra characters", pi.str, pi.s);
+    return n;
+}
+
+static CircArray
+circ_array_new() {
+    CircArray   ca;
+    
+    if (0 == (ca = (CircArray)malloc(sizeof(struct _CircArray)))) {
+        rb_raise(rb_eNoMemError, "not enough memory\n");
+    }
+    ca->objs = ca->obj_array;
+    ca->size = sizeof(ca->obj_array) / sizeof(VALUE);
+    ca->cnt = 0;
+    
+    return ca;
+}
+
+static void
+circ_array_free(CircArray ca) {
+    if (ca->objs != ca->obj_array) {
+        free(ca->objs);
+    }
+    free(ca);
+}
+
+static void
+circ_array_set(CircArray ca, VALUE obj, unsigned long id) {
+    if (0 < id && 0 != ca) {
+        unsigned long   i;
+
+        if (ca->size < id) {
+            unsigned long       cnt = id + 512;
+
+            if (ca->objs == ca->obj_array) {
+                if (0 == (ca->objs = (VALUE*)malloc(sizeof(VALUE) * cnt))) {
+                    rb_raise(rb_eNoMemError, "not enough memory\n");
+                }
+                memcpy(ca->objs, ca->obj_array, sizeof(VALUE) * ca->cnt);
+            } else { 
+                if (0 == (ca->objs = (VALUE*)realloc(ca->objs, sizeof(VALUE) * cnt))) {
+                    rb_raise(rb_eNoMemError, "not enough memory\n");
+                }
+            }
+            ca->size = cnt;
+        }
+        id--;
+        for (i = ca->cnt; i < id; i++) {
+            ca->objs[i] = Qnil;
+        }
+        ca->objs[id] = obj;
+        if (ca->cnt <= id) {
+            ca->cnt = id + 1;
+        }
+    }
+}
+
+static VALUE
+circ_array_get(CircArray ca, unsigned long id) {
+    VALUE       obj = Qnil;
+
+    if (id <= ca->cnt && 0 != ca) {
+        obj = ca->objs[id - 1];
     }
     return obj;
 }
@@ -207,7 +285,7 @@ read_next(ParseInfo pi, int hint) {
 	obj = read_obj(pi);
 	break;
     case '[':
-	obj = read_array(pi);
+	obj = read_array(pi, hint);
 	break;
     case '"':
 	obj = read_str(pi, hint);
@@ -256,6 +334,7 @@ read_obj(ParseInfo pi) {
     VALUE	val = Qundef;
     const char	*ks;
     int		obj_type = T_NONE;
+    const char	*json_class_name = 0;
     
     pi->s++;
     next_non_white(pi);
@@ -306,8 +385,24 @@ read_obj(ParseInfo pi) {
 		    obj_type = T_OBJECT;
 		    key = Qundef;
 		    break;
-		case 'i': // Id for circular reference
-		    // TBD
+		case 'u': // Struct
+		    obj = read_next(pi, T_STRUCT);
+		    obj_type = T_STRUCT;
+		    key = Qundef;
+		    break;
+		    /*
+		case 'r': // Id for circular reference
+		    val = read_next(pi, T_FIXNUM);
+		    if (T_FIXNUM == rb_type(val)) {
+			obj_type = T_FIXNUM;
+			obj = circ_array_get(pi->circ_array, NUM2ULONG(val));
+			if (Qundef == obj || Qnil == obj) {
+			    raise_error("Failed to find referenced object", pi->str, pi->s);
+			}
+			key = Qundef;
+		    }
+		    break;
+		    */
 		default:
 		    // handle later
 		    break;
@@ -318,41 +413,55 @@ read_obj(ParseInfo pi) {
 	    if (Qundef == val && Qundef == (val = read_next(pi, 0))) {
 		raise_error("unexpected character", pi->str, pi->s);
 	    }
-	    if (ObjectMode == pi->options->mode &&
-		0 != ks && '^' == *ks && '#' == ks[1] &&
-		(T_NONE == obj_type || T_HASH == obj_type) &&
-		rb_type(val) == T_ARRAY && 2 == RARRAY_LEN(val)) {  // Hash entry
-		VALUE	*np = RARRAY_PTR(val);
-
-		key = *np;
-		val = *(np + 1);
-	    }
 	    if (Qundef == obj) {
 		obj = rb_hash_new();
 		obj_type = T_HASH;
 	    }
-	    if (T_OBJECT == obj_type) {
-		VALUE       *slot;
-		ID          var_id;
-
-		if (Qundef == (var_id = oj_cache_get(oj_attr_cache, ks, &slot))) {
-		    char	attr[1024];
-
-		    if ('~' == *ks) {
-			strncpy(attr, ks + 1, sizeof(attr) - 1);
-		    } else {
-			*attr = '@';
-			strncpy(attr + 1, ks, sizeof(attr) - 2);
+	    if (ObjectMode == pi->options->mode && 0 != ks && '^' == *ks) {
+		int	val_type = rb_type(val);
+
+		if ('i' == ks[1] && '\0' == ks[2] && T_FIXNUM == val_type) {
+		    circ_array_set(pi->circ_array, obj, NUM2ULONG(val));
+		    key = Qundef;
+		} else if ('#' == ks[1] &&
+		    (T_NONE == obj_type || T_HASH == obj_type) &&
+		    T_ARRAY == val_type && 2 == RARRAY_LEN(val)) {  // Hash entry
+		    VALUE	*np = RARRAY_PTR(val);
+
+		    key = *np;
+		    val = *(np + 1);
+		}
+	    }
+	    if (Qundef != key) {
+		if (T_OBJECT == obj_type) {
+		    VALUE       *slot;
+		    ID          var_id;
+
+		    if (Qundef == (var_id = oj_cache_get(oj_attr_cache, ks, &slot))) {
+			char	attr[1024];
+
+			if ('~' == *ks) {
+			    strncpy(attr, ks + 1, sizeof(attr) - 1);
+			} else {
+			    *attr = '@';
+			    strncpy(attr + 1, ks, sizeof(attr) - 2);
+			}
+			attr[sizeof(attr) - 1] = '\0';
+			var_id = rb_intern(attr);
+			*slot = var_id;
+		    }
+		    rb_ivar_set(obj, var_id, val);
+		} else if (T_HASH == obj_type) {
+		    rb_hash_aset(obj, key, val);
+		    if ((CompatMode == pi->options->mode || ObjectMode == pi->options->mode) &&
+			0 == json_class_name &&
+			0 != ks && 'j' == *ks && 0 == strcmp("json_class", ks) &&
+			T_STRING == rb_type(val)) {
+			json_class_name = StringValuePtr(val);
 		    }
-		    attr[sizeof(attr) - 1] = '\0';
-		    var_id = rb_intern(attr);
-		    *slot = var_id;
+		} else {
+		    raise_error("invalid Object format, too many Hash entries.", pi->str, pi->s);
 		}
-		rb_ivar_set(obj, var_id, val);
-	    } else if (T_HASH == obj_type) {
-		rb_hash_aset(obj, key, val);
-	    } else {
-		raise_error("invalid Object format, too many Hash entries.", pi->str, pi->s);
 	    }
 	}
 	next_non_white(pi);
@@ -366,26 +475,69 @@ read_obj(ParseInfo pi) {
 	    raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
 	}
     }
+    if (0 != json_class_name) {
+	VALUE	clas = classname2class(json_class_name, pi);
+	VALUE	args[1];
+
+	*args = obj;
+	obj = rb_funcall2(clas, oj_json_create_id, 1, args);
+    }
     return obj;
 }
 
 static VALUE
-read_array(ParseInfo pi) {
-    VALUE	a = rb_ary_new();
+read_array(ParseInfo pi, int hint) {
+    VALUE	a = Qundef;
     VALUE	e;
+    int		type = T_NONE;
+    int		cnt = 0;
+    long	slen = 0;
+    int		a_str;
 
     pi->s++;
     next_non_white(pi);
     if (']' == *pi->s) {
 	pi->s++;
-	return a;
+	return rb_ary_new();
     }
     while (1) {
+	next_non_white(pi);
+	a_str = ('"' == *pi->s);
 	if (Qundef == (e = read_next(pi, 0))) {
 	    raise_error("unexpected character", pi->str, pi->s);
 	}
-        rb_ary_push(a, e);
-	next_non_white(pi);	// skip white space
+#ifndef NO_RSTRUCT
+	if (Qundef == a && T_STRUCT == hint && T_STRING == rb_type(e)) {
+	    a = structname2obj(StringValuePtr(e));
+	    type = T_STRUCT;
+	    slen = RSTRUCT_LEN(a);
+	    e = Qundef;
+	}
+#endif
+	if (Qundef == a) {
+	    a = rb_ary_new();
+	    type = T_ARRAY;
+	}
+	if (a_str && T_FIXNUM == rb_type(e)) {
+	    circ_array_set(pi->circ_array, a, NUM2ULONG(e));
+	    e = Qundef;
+	}
+	if (Qundef != e) {
+	    if (T_STRUCT == type) {
+#ifdef NO_RSTRUCT
+		raise_error("Ruby structs not supported with this version of Ruby", pi->str, pi->s);
+#else
+		if (slen <= cnt) {
+		    raise_error("Too many elements for Struct", pi->str, pi->s);
+		}
+		RSTRUCT_PTR(a)[cnt] = e;
+#endif
+	    } else {
+		a = rb_ary_push(a, e);
+	    }
+	    cnt++;
+	}
+	next_non_white(pi);
 	if (',' == *pi->s) {
 	    pi->s++;
 	} else if (']' == *pi->s) {
@@ -400,9 +552,12 @@ read_array(ParseInfo pi) {
 
 static VALUE
 read_str(ParseInfo pi, int hint) {
-    char	*text = read_quoted_value(pi);
+    char	*text;
     VALUE	obj;
+    int		escaped;
 
+    escaped = ('\\' == pi->s[1]);
+    text = read_quoted_value(pi);
     if (ObjectMode != pi->options->mode) {
 	hint = T_STRING;
     }
@@ -436,28 +591,29 @@ read_str(ParseInfo pi, int hint) {
 	break;
     case 0:
     default:
-	if (':' == *text) {
-	    if (':' == text[1]) { // escaped :, it s string
-		obj = rb_str_new2(text + 1);
-#ifdef HAVE_RUBY_ENCODING_H
-		if (0 != pi->encoding) {
-		    rb_enc_associate(obj, pi->encoding);
-		}
-#endif
-	    } else { // Symbol
+	obj = Qundef;
+	if (':' == *text && !escaped) { // Symbol
 #ifdef HAVE_RUBY_ENCODING_H
-		if (0 != pi->encoding) {
-		    obj = rb_str_new2(text + 1);
-		    rb_enc_associate(obj, pi->encoding);
-		    obj = rb_funcall(obj, oj_to_sym_id, 0);
-		} else {
-		    obj = ID2SYM(rb_intern(text + 1));
-		}
-#else
+	    if (0 != pi->encoding) {
+		obj = rb_str_new2(text + 1);
+		rb_enc_associate(obj, pi->encoding);
+		obj = rb_funcall(obj, oj_to_sym_id, 0);
+	    } else {
 		obj = ID2SYM(rb_intern(text + 1));
+	    }
+#else
+	    obj = ID2SYM(rb_intern(text + 1));
 #endif
+	} else if (ObjectMode == pi->options->mode && '^' == *text && '\0' != text[2]) {
+	    char	c1 = text[1];
+
+	    if ('r' == c1) {
+		obj = circ_array_get(pi->circ_array, read_ulong(text + 2, pi));
+	    } else if ('i' == c1) {
+		obj = ULONG2NUM(read_ulong(text + 2, pi));
 	    }
-	} else {
+	}
+	if (Qundef == obj) {
 	    obj = rb_str_new2(text);
 #ifdef HAVE_RUBY_ENCODING_H
 	    if (0 != pi->encoding) {
@@ -644,7 +800,6 @@ read_quoted_value(ParseInfo pi) {
     h++;	// skip quote character
     t++;
     value = h;
-    // TBD can whole string be read in and then eval-ed by ruby of there is a special character
     for (; '"' != *h; h++, t++) {
 	if ('\0' == *h) {
 	    pi->s = h;
@@ -661,7 +816,6 @@ read_quoted_value(ParseInfo pi) {
 	    case '/':	*t = '/';	break;
 	    case '\\':	*t = '\\';	break;
 	    case 'u':
-		// TBD if first character is 00 then skip it
 		h++;
 		*t = read_hex(pi, h);
 		h += 2;
@@ -685,3 +839,38 @@ read_quoted_value(ParseInfo pi) {
 
     return value;
 }
+
+VALUE
+oj_parse(char *json, Options options) {
+    VALUE		obj;
+    struct _ParseInfo	pi;
+
+    if (0 == json) {
+	raise_error("Invalid arg, xml string can not be null", json, 0);
+    }
+    /* initialize parse info */
+    pi.str = json;
+    pi.s = json;
+    pi.circ_array = 0;
+    if (Yes == options->circular) {
+	pi.circ_array = circ_array_new();
+    }
+#ifdef HAVE_RUBY_ENCODING_H
+    pi.encoding = ('\0' == *options->encoding) ? 0 : rb_enc_find(options->encoding);
+#else
+    pi.encoding = 0;
+#endif
+    pi.options = options;
+    obj = read_next(&pi, 0);
+    if (Yes == options->circular) {
+	circ_array_free(pi.circ_array);
+    }
+    if (Qundef == obj) {
+	raise_error("no object read", pi.str, pi.s);
+    }
+    next_non_white(&pi);
+    if ('\0' != *pi.s) {
+	raise_error("invalid format, extra characters", pi.str, pi.s);
+    }
+    return obj;
+}