ox 2.0.0 → 2.0.1

data/ext/ox/ox.c

@@ -38,7 +38,7 @@
 #include "sax.h"
 
 /* maximum to allocate on the stack, arbitrary limit */
-#define SMALL_XML	65536
+#define SMALL_XML	4096
 
 typedef struct _YesNoOpt {
     VALUE	sym;
@@ -57,6 +57,7 @@ ID	ox_at_value_id;
 ID	ox_attr_id;
 ID	ox_attr_value_id;
 ID	ox_attributes_id;
+ID	ox_attrs_done_id;
 ID	ox_beg_id;
 ID	ox_cdata_id;
 ID	ox_comment_id;
@@ -384,21 +385,26 @@ to_obj(VALUE self, VALUE ruby_xml) {
     size_t		len;
     VALUE		obj;
     struct _Options	options = ox_default_options;
+    struct _Err		err;
 
+    err_init(&err);
     Check_Type(ruby_xml, T_STRING);
     /* the xml string gets modified so make a copy of it */
     len = RSTRING_LEN(ruby_xml) + 1;
+    x = defuse_bom(StringValuePtr(ruby_xml), &options);
     if (SMALL_XML < len) {
 	xml = ALLOC_N(char, len);
     } else {
 	xml = ALLOCA_N(char, len);
     }
-    memcpy(xml, StringValuePtr(ruby_xml), len);
-    x = defuse_bom(xml, &options);
-    obj = ox_parse(x, ox_obj_callbacks, 0, &options);
+    memcpy(xml, x, len);
+    obj = ox_parse(xml, ox_obj_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
+    if (err_has(&err)) {
+	ox_err_raise(&err);
+    }
     return obj;
 }
 
@@ -415,26 +421,31 @@ to_gen(VALUE self, VALUE ruby_xml) {
     size_t		len;
     VALUE		obj;
     struct _Options	options = ox_default_options;
+    struct _Err		err;
 
+    err_init(&err);
     Check_Type(ruby_xml, T_STRING);
     /* the xml string gets modified so make a copy of it */
     len = RSTRING_LEN(ruby_xml) + 1;
+    x = defuse_bom(StringValuePtr(ruby_xml), &options);
     if (SMALL_XML < len) {
 	xml = ALLOC_N(char, len);
     } else {
 	xml = ALLOCA_N(char, len);
     }
-    memcpy(xml, StringValuePtr(ruby_xml), len);
-    x = defuse_bom(xml, &options);
-    obj = ox_parse(x, ox_gen_callbacks, 0, &options);
+    memcpy(xml, x, len);
+    obj = ox_parse(xml, ox_gen_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
+    if (err_has(&err)) {
+	ox_err_raise(&err);
+    }
     return obj;
 }
 
 static VALUE
-load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding) {
+load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
     VALUE		obj;
     struct _Options	options = ox_default_options;
 
@@ -499,19 +510,19 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding) {
     xml = defuse_bom(xml, &options);
     switch (options.mode) {
     case ObjMode:
-	obj = ox_parse(xml, ox_obj_callbacks, 0, &options);
+	obj = ox_parse(xml, ox_obj_callbacks, 0, &options, err);
 	break;
     case GenMode:
-	obj = ox_parse(xml, ox_gen_callbacks, 0, &options);
+	obj = ox_parse(xml, ox_gen_callbacks, 0, &options, err);
 	break;
     case LimMode:
-	obj = ox_parse(xml, ox_limited_callbacks, 0, &options);
+	obj = ox_parse(xml, ox_limited_callbacks, 0, &options, err);
 	break;
     case NoMode:
-	obj = ox_parse(xml, ox_nomode_callbacks, 0, &options);
+	obj = ox_parse(xml, ox_nomode_callbacks, 0, &options, err);
 	break;
     default:
-	obj = ox_parse(xml, ox_gen_callbacks, 0, &options);
+	obj = ox_parse(xml, ox_gen_callbacks, 0, &options, err);
 	break;
     }
     return obj;
@@ -541,7 +552,9 @@ load_str(int argc, VALUE *argv, VALUE self) {
     size_t	len;
     VALUE	obj;
     VALUE	encoding;
-    
+    struct _Err	err;
+
+    err_init(&err);
     Check_Type(*argv, T_STRING);
     /* the xml string gets modified so make a copy of it */
     len = RSTRING_LEN(*argv) + 1;
@@ -562,10 +575,13 @@ load_str(int argc, VALUE *argv, VALUE self) {
     encoding = Qnil;
 #endif
     memcpy(xml, StringValuePtr(*argv), len);
-    obj = load(xml, argc - 1, argv + 1, self, encoding);
+    obj = load(xml, argc - 1, argv + 1, self, encoding, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
+    if (err_has(&err)) {
+	ox_err_raise(&err);
+    }
     return obj;
 }
 
@@ -594,7 +610,9 @@ load_file(int argc, VALUE *argv, VALUE self) {
     FILE	*f;
     size_t	len;
     VALUE	obj;
-    
+    struct _Err	err;
+
+    err_init(&err);
     Check_Type(*argv, T_STRING);
     path = StringValuePtr(*argv);
     if (0 == (f = fopen(path, "r"))) {
@@ -609,15 +627,19 @@ load_file(int argc, VALUE *argv, VALUE self) {
     }
     fseek(f, 0, SEEK_SET);
     if (len != fread(xml, 1, len, f)) {
-	fclose(f);
-	rb_raise(rb_eLoadError, "Failed to read %ld bytes from %s.\n", (long)len, path);
+	ox_err_set(&err, rb_eLoadError, "Failed to read %ld bytes from %s.\n", (long)len, path);
+	obj = Qnil;
+    } else {
+	xml[len] = '\0';
+	obj = load(xml, argc - 1, argv + 1, self, Qnil, &err);
     }
     fclose(f);
-    xml[len] = '\0';
-    obj = load(xml, argc - 1, argv + 1, self, Qnil);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
+    if (err_has(&err)) {
+	ox_err_raise(&err);
+    }
     return obj;
 }
 
@@ -832,6 +854,7 @@ void Init_ox() {
     ox_attr_id = rb_intern("attr");
     ox_attr_value_id = rb_intern("attr_value");
     ox_attributes_id = rb_intern("@attributes");
+    ox_attrs_done_id = rb_intern("attrs_done");
     ox_beg_id = rb_intern("@beg");
     ox_cdata_id = rb_intern("cdata");
     ox_comment_id = rb_intern("comment");

data/ext/ox/ox.h

@@ -59,11 +59,14 @@ enum st_retval {ST_CONTINUE = 0, ST_STOP = 1, ST_DELETE = 2, ST_CHECK};
 
 #include "cache.h"
 
+#include "err.h"
+#include "type.h"
+#include "attr.h"
+#include "helper.h"
+
 #define raise_error(msg, xml, current) _ox_raise_error(msg, xml, current, __FILE__, __LINE__)
 
 #define MAX_TEXT_LEN	4096
-#define MAX_ATTRS	1024
-#define MAX_DEPTH	1024
 
 #define SILENT		0
 #define TRACE		1
@@ -115,46 +118,6 @@ typedef enum {
     NoMode   = 0
 } LoadMode;
 
-typedef enum {
-    NoCode	   = 0,
-    ArrayCode	   = 'a',
-    String64Code   = 'b', /* base64 encoded String */
-    ClassCode	   = 'c',
-    Symbol64Code   = 'd', /* base64 encoded Symbol */
-    DateCode	   = 'D',
-    ExceptionCode  = 'e',
-    FloatCode	   = 'f',
-    RegexpCode	   = 'g',
-    HashCode	   = 'h',
-    FixnumCode	   = 'i',
-    BignumCode	   = 'j',
-    KeyCode	   = 'k', /* indicates the value is a hash key, kind of a hack */
-    RationalCode   = 'l',
-    SymbolCode	   = 'm',
-    FalseClassCode = 'n',
-    ObjectCode	   = 'o',
-    RefCode	   = 'p',
-    RangeCode	   = 'r',
-    StringCode	   = 's',
-    TimeCode	   = 't',
-    StructCode	   = 'u',
-    ComplexCode	   = 'v',
-    RawCode	   = 'x',
-    TrueClassCode  = 'y',
-    NilClassCode   = 'z',
-} Type;
-
-typedef struct _Attr {
-    const char	*name;
-    const char	*value;
-} *Attr;
-
-typedef struct _Helper {
-    ID		var;	/* Object var ID */
-    VALUE	obj;	/* object created or Qundef if not appropriate */
-    Type	type;	/* type of object in obj */
-} *Helper;
-
 typedef struct _PInfo	*PInfo;
 
 typedef struct _ParseCallbacks {
@@ -197,8 +160,8 @@ typedef struct _Options {
 
 /* parse information structure */
 struct _PInfo {
-    struct _Helper	helpers[MAX_DEPTH];
-    Helper		h;		/* current helper or 0 if not set */
+    struct _HelperStack	helpers;
+    struct _Err		err;
     char		*str;		/* buffer being read from */
     char		*s;		/* current position in buffer */
     VALUE		obj;
@@ -209,7 +172,7 @@ struct _PInfo {
     char		last;		/* last character read, rarely set */
 };
 
-extern VALUE	ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options);
+extern VALUE	ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err);
 extern void	_ox_raise_error(const char *msg, const char *xml, const char *current, const char* file, int line);
 
 extern void	ox_sax_define(void);
@@ -228,6 +191,7 @@ extern ID	ox_at_line_id;
 extern ID	ox_at_value_id;
 extern ID	ox_attr_id;
 extern ID	ox_attr_value_id;
+extern ID	ox_attrs_done_id;
 extern ID	ox_attributes_id;
 extern ID	ox_beg_id;
 extern ID	ox_cdata_id;
@@ -273,11 +237,9 @@ extern VALUE		ox_utf8_encoding;
 extern void		*ox_utf8_encoding;
 #endif
 
-extern VALUE	ox_arg_error_class;
 extern VALUE	ox_date_class;
 extern VALUE	ox_empty_string;
 extern VALUE	ox_encoding_sym;
-extern VALUE	ox_parse_error_class;
 extern VALUE	ox_stringio_class;
 extern VALUE	ox_struct_class;
 extern VALUE	ox_time_class;

data/ext/ox/parse.c

@@ -35,6 +35,9 @@
 
 #include "ruby.h"
 #include "ox.h"
+#include "err.h"
+#include "attr.h"
+#include "helper.h"
 
 static void	read_instruction(PInfo pi);
 static void	read_doctype(PInfo pi);
@@ -99,20 +102,22 @@ next_white(PInfo pi) {
 }
 
 VALUE
-ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
+ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err) {
     struct _PInfo	pi;
     int			body_read = 0;
 
     if (0 == xml) {
-	raise_error("Invalid arg, xml string can not be null", xml, 0);
+	set_error(err, "Invalid arg, xml string can not be null", xml, 0);
+	return Qnil;
     }
     if (DEBUG <= options->trace) {
 	printf("Parsing xml:\n%s\n", xml);
     }
     /* initialize parse info */
+    helper_stack_init(&pi.helpers);
+    err_init(&pi.err);
     pi.str = xml;
     pi.s = xml;
-    pi.h = 0;
     pi.pcb = pcb;
     pi.obj = Qnil;
     pi.circ_array = 0;
@@ -127,7 +132,9 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
 	    break;
 	}
 	if ('<' != *pi.s) {		/* all top level entities start with < */
-	    raise_error("invalid format, expected <", pi.str, pi.s);
+	    set_error(err, "invalid format, expected <", pi.str, pi.s);
+	    helper_stack_cleanup(&pi.helpers);
+	    return Qnil;
 	}
 	pi.s++;		/* past < */
 	switch (*pi.s) {
@@ -138,11 +145,15 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
 	case '!':	/* comment or doctype */
 	    pi.s++;
 	    if ('\0' == *pi.s) {
-		raise_error("invalid format, DOCTYPE or comment not terminated", pi.str, pi.s);
+		set_error(err, "invalid format, DOCTYPE or comment not terminated", pi.str, pi.s);
+		helper_stack_cleanup(&pi.helpers);
+		return Qnil;
 	    } else if ('-' == *pi.s) {
 		pi.s++;	/* skip - */
 		if ('-' != *pi.s) {
-		    raise_error("invalid format, bad comment format", pi.str, pi.s);
+		    set_error(err, "invalid format, bad comment format", pi.str, pi.s);
+		    helper_stack_cleanup(&pi.helpers);
+		    return Qnil;
 		} else {
 		    pi.s++;	/* skip second - */
 		    read_comment(&pi);
@@ -151,17 +162,27 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
 		pi.s += 7;
 		read_doctype(&pi);
 	    } else {
-		raise_error("invalid format, DOCTYPE or comment expected", pi.str, pi.s);
+		set_error(err, "invalid format, DOCTYPE or comment expected", pi.str, pi.s);
+		helper_stack_cleanup(&pi.helpers);
+		return Qnil;
 	    }
 	    break;
 	case '\0':
-	    raise_error("invalid format, document not terminated", pi.str, pi.s);
+	    set_error(err, "invalid format, document not terminated", pi.str, pi.s);
+	    helper_stack_cleanup(&pi.helpers);
+	    return Qnil;
 	default:
 	    read_element(&pi);
 	    body_read = 1;
 	    break;
 	}
+	if (err_has(&pi.err)) {
+	    *err = pi.err;
+	    helper_stack_cleanup(&pi.helpers);
+	    return Qnil;
+	}
     }
+    helper_stack_cleanup(&pi.helpers);
     return pi.obj;
 }
 
@@ -191,20 +212,25 @@ gather_content(const char *src, char *content, size_t len) {
 static void
 read_instruction(PInfo pi) {
     char		content[1024];
-    struct _Attr	attrs[MAX_ATTRS + 1];
-    Attr		a = attrs;
+    struct _AttrStack	attrs;
+    char		*attr_name;
+    char		*attr_value;
     char		*target;
     char		*end;
     char		c;
     char		*cend;
     int			attrs_ok = 1;
 
+
     *content = '\0';
-    memset(attrs, 0, sizeof(attrs));
-    target = read_name_token(pi);
+    attr_stack_init(&attrs);
+    if (0 == (target = read_name_token(pi))) {
+	return;
+    }
     end = pi->s;
     if (0 == (cend = gather_content(pi->s, content, sizeof(content) - 1))) {
-	raise_error("processing instruction content too large or not terminated", pi->str, pi->s);
+	set_error(&pi->err, "processing instruction content too large or not terminated", pi->str, pi->s);
+	return;
     }
     next_non_white(pi);
     c = *pi->s;
@@ -213,10 +239,15 @@ read_instruction(PInfo pi) {
 	while ('?' != c) {
 	    pi->last = 0;
 	    if ('\0' == *pi->s) {
-		raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+		attr_stack_cleanup(&attrs);
+		set_error(&pi->err, "invalid format, processing instruction not terminated", pi->str, pi->s);
+		return;
 	    }
 	    next_non_white(pi);
-	    a->name = read_name_token(pi);
+	    if (0 == (attr_name = read_name_token(pi))) {
+		attr_stack_cleanup(&attrs);
+		return;
+	    }
 	    end = pi->s;
 	    next_non_white(pi);
 	    if ('=' != *pi->s++) {
@@ -226,12 +257,11 @@ read_instruction(PInfo pi) {
 	    *end = '\0'; /* terminate name */
 	    /* read value */
 	    next_non_white(pi);
-	    a->value = read_quoted_value(pi);
-	    a++;
-	    if (MAX_ATTRS <= (a - attrs)) {
-		attrs_ok = 0;
-		break;
+	    if (0 == (attr_value = read_quoted_value(pi))) {
+		attr_stack_cleanup(&attrs);
+		return;
 	    }
+	    attr_stack_push(&attrs, attr_name, attr_value);
 	    next_non_white(pi);
 	    if ('\0' == pi->last) {
 		c = *pi->s;
@@ -247,18 +277,21 @@ read_instruction(PInfo pi) {
     }
     if (attrs_ok) {
 	if ('>' != *pi->s++) {
-	    raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+	    attr_stack_cleanup(&attrs);
+	    set_error(&pi->err, "invalid format, processing instruction not terminated", pi->str, pi->s);
+	    return;
 	}
     } else {
 	pi->s = cend + 1;
     }
     if (0 != pi->pcb->instruct) {
 	if (attrs_ok) {
-	    pi->pcb->instruct(pi, target, attrs, 0);
+	    pi->pcb->instruct(pi, target, attrs.head, 0);
 	} else {
-	    pi->pcb->instruct(pi, target, attrs, content);
+	    pi->pcb->instruct(pi, target, attrs.head, content);
 	}
     }
+    attr_stack_cleanup(&attrs);
 }
 
 /* Entered after the "<!DOCTYPE" sequence plus the first character after
@@ -275,7 +308,8 @@ read_doctype(PInfo pi) {
     while (1) {
 	c = *pi->s++;
 	if ('\0' == c) {
-	    raise_error("invalid format, prolog not terminated", pi->str, pi->s);
+	    set_error(&pi->err, "invalid format, prolog not terminated", pi->str, pi->s);
+	    return;
 	} else if ('<' == c) {
 	    depth++;
 	} else if ('>' == c) {
@@ -306,7 +340,8 @@ read_comment(PInfo pi) {
     comment = pi->s;
     end = strstr(pi->s, "-->");
     if (0 == end) {
-	raise_error("invalid format, comment not terminated", pi->str, pi->s);
+	set_error(&pi->err, "invalid format, comment not terminated", pi->str, pi->s);
+	return;
     }
     for (s = end - 1; pi->s < s && !done; s--) {
 	switch(*s) {
@@ -334,8 +369,9 @@ read_comment(PInfo pi) {
  */
 static char*
 read_element(PInfo pi) {
-    struct _Attr	attrs[MAX_ATTRS];
-    Attr		ap = attrs;
+    struct _AttrStack	attrs;
+    const char		*attr_name;
+    const char		*attr_value;
     char		*name;
     char		*ename;
     char		*end;
@@ -344,7 +380,10 @@ read_element(PInfo pi) {
     int			hasChildren = 0;
     int			done = 0;
 
-    ename = read_name_token(pi);
+    attr_stack_init(&attrs);
+    if (0 == (ename = read_name_token(pi))) {
+	return 0;
+    }
     end = pi->s;
     elen = end - ename;
     next_non_white(pi);
@@ -355,13 +394,15 @@ read_element(PInfo pi) {
 	pi->s++;
 	if ('>' != *pi->s) {
 	    /*printf("*** '%s' ***\n", pi->s); */
-	    raise_error("invalid format, element not closed", pi->str, pi->s);
+	    attr_stack_cleanup(&attrs);
+	    set_error(&pi->err, "invalid format, element not closed", pi->str, pi->s);
+	    return 0;
 	}
 	pi->s++;	/* past > */
-	ap->name = 0;
-	pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	pi->pcb->add_element(pi, ename, attrs.head, hasChildren);
 	pi->pcb->end_element(pi, ename);
 
+	attr_stack_cleanup(&attrs);
 	return 0;
     }
     /* read attribute names until the close (/ or >) is reached */
@@ -373,31 +414,37 @@ read_element(PInfo pi) {
 	pi->last = 0;
 	switch (c) {
 	case '\0':
-	    raise_error("invalid format, document not terminated", pi->str, pi->s);
+	    attr_stack_cleanup(&attrs);
+	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+	    return 0;
 	case '/':
 	    /* Element with just attributes. */
 	    pi->s++;
 	    if ('>' != *pi->s) {
-		raise_error("invalid format, element not closed", pi->str, pi->s);
+		attr_stack_cleanup(&attrs);
+		set_error(&pi->err, "invalid format, element not closed", pi->str, pi->s);
+		return 0;
 	    }
 	    pi->s++;
-	    ap->name = 0;
-	    pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	    pi->pcb->add_element(pi, ename, attrs.head, hasChildren);
 	    pi->pcb->end_element(pi, ename);
 
+	    attr_stack_cleanup(&attrs);
 	    return 0;
 	case '>':
 	    /* has either children or a value */
 	    pi->s++;
 	    hasChildren = 1;
 	    done = 1;
-	    ap->name = 0;
-	    pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	    pi->pcb->add_element(pi, ename, attrs.head, hasChildren);
 	    break;
 	default:
 	    /* Attribute name so it's an element and the attribute will be */
 	    /* added to it. */
-	    ap->name = read_name_token(pi);
+	    if (0 == (attr_name = read_name_token(pi))) {
+		attr_stack_cleanup(&attrs);
+		return 0;
+	    }
 	    end = pi->s;
 	    next_non_white(pi);
 	    if ('=' != *pi->s++) {
@@ -405,29 +452,29 @@ read_element(PInfo pi) {
 		    pi->s--;
 		    pi->last = *pi->s;
 		    *end = '\0'; /* terminate name */
-		    ap->value = "";
-		    ap++;
-		    if (MAX_ATTRS <= (ap - attrs)) {
-			raise_error("too many attributes", pi->str, pi->s);
-		    }
+		    attr_value = "";
+		    attr_stack_push(&attrs, attr_name, attr_value);
 		    break;
 		} else {
-		    raise_error("invalid format, no attribute value", pi->str, pi->s);
+		    attr_stack_cleanup(&attrs);
+		    set_error(&pi->err, "invalid format, no attribute value", pi->str, pi->s);
+		    return 0;
 		}
 	    }
 	    *end = '\0'; /* terminate name */
 	    /* read value */
 	    next_non_white(pi);
-	    ap->value = read_quoted_value(pi);
-	    if (0 != strchr(ap->value, '&')) {
-		if (0 != collapse_special(pi, (char*)ap->value)) {
-		    raise_error("invalid format, special character does not end with a semicolon", pi->str, pi->s);
-		}
+	    if (0 == (attr_value = read_quoted_value(pi))) {
+		return 0;
 	    }
-	    ap++;
-	    if (MAX_ATTRS <= (ap - attrs)) {
-		raise_error("too many attributes", pi->str, pi->s);
+	    if (0 != strchr(attr_value, '&')) {
+		if (0 != collapse_special(pi, (char*)attr_value)) {
+		    attr_stack_cleanup(&attrs);
+		    set_error(&pi->err, "invalid format, special character does not end with a semicolon", pi->str, pi->s);
+		    return 0;
+		}
 	    }
+	    attr_stack_push(&attrs, attr_name, attr_value);
 	    break;
 	}
 	if ('\0' == pi->last) {
@@ -448,7 +495,9 @@ read_element(PInfo pi) {
 	    next_non_white(pi);
 	    c = *pi->s++;
 	    if ('\0' == c) {
-		raise_error("invalid format, document not terminated", pi->str, pi->s);
+		attr_stack_cleanup(&attrs);
+		set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+		return 0;
 	    }
 	    if ('<' == c) {
 		char	*slash;
@@ -465,7 +514,9 @@ read_element(PInfo pi) {
 			pi->s += 7;
 			read_cdata(pi);
 		    } else {
-			raise_error("invalid format, invalid comment or CDATA format", pi->str, pi->s);
+			attr_stack_cleanup(&attrs);
+			set_error(&pi->err, "invalid format, invalid comment or CDATA format", pi->str, pi->s);
+			return 0;
 		    }
 		    break;
 		case '?':	/* processing instruction */
@@ -475,21 +526,28 @@ read_element(PInfo pi) {
 		case '/':
 		    slash = pi->s;
 		    pi->s++;
-		    name = read_name_token(pi);
+		    if (0 == (name = read_name_token(pi))) {
+			attr_stack_cleanup(&attrs);
+			return 0;
+		    }
 		    end = pi->s;
 		    next_non_white(pi);
 		    c = *pi->s;
 		    *end = '\0';
 		    if (0 != strcmp(name, ename)) {
+			attr_stack_cleanup(&attrs);
 			if (TolerantEffort == pi->options->effort) {
 			    pi->pcb->end_element(pi, ename);
 			    return name;
 			} else {
-			    raise_error("invalid format, elements overlap", pi->str, pi->s);
+			    set_error(&pi->err, "invalid format, elements overlap", pi->str, pi->s);
+			    return 0;
 			}
 		    }
 		    if ('>' != c) {
-			raise_error("invalid format, element not closed", pi->str, pi->s);
+			attr_stack_cleanup(&attrs);
+			set_error(&pi->err, "invalid format, element not closed", pi->str, pi->s);
+			return 0;
 		    }
 		    if (first && start != slash - 1) {
 			/* some white space between start and here so add as text */
@@ -498,18 +556,22 @@ read_element(PInfo pi) {
 		    }
 		    pi->s++;
 		    pi->pcb->end_element(pi, ename);
+		    attr_stack_cleanup(&attrs);
 		    return 0;
 		case '\0':
+		    attr_stack_cleanup(&attrs);
 		    if (TolerantEffort == pi->options->effort) {
 			return 0;
 		    } else {
-			raise_error("invalid format, document not terminated", pi->str, pi->s);
+			set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+			return 0;
 		    }
 		default:
 		    first = 0;
 		    /* a child element */
 		    // Child closed with mismatched name.
 		    if (0 != (name = read_element(pi))) {
+			attr_stack_cleanup(&attrs);
 			if (0 == strcmp(name, ename)) {
 			    pi->s++;
 			    pi->pcb->end_element(pi, ename);
@@ -518,6 +580,8 @@ read_element(PInfo pi) {
 			    pi->pcb->end_element(pi, ename);
 			    return name;
 			}
+		    } else if (err_has(&pi->err)) {
+			return 0;
 		    }
 		    break;
 		}
@@ -534,11 +598,13 @@ read_element(PInfo pi) {
 		    /* close tag after text so treat as a value */
 		    pi->s += elen + 3;
 		    pi->pcb->end_element(pi, ename);
+		    attr_stack_cleanup(&attrs);
 		    return 0;
 		}
 	    }
 	}
     }
+    attr_stack_cleanup(&attrs);
     return 0;
 }
 
@@ -559,7 +625,8 @@ read_text(PInfo pi) {
 	    pi->s--;
 	    break;
 	case '\0':
-	    raise_error("invalid format, document not terminated", pi->str, pi->s);
+	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+	    return;
 	default:
 	    if (end <= (b + (('&' == c) ? 7 : 0))) { /* extra 8 for special just in case it is sequence of bytes */
 		unsigned long	size;
@@ -621,7 +688,8 @@ read_reduced_text(PInfo pi) {
 	    pi->s--;
 	    break;
 	case '\0':
-	    raise_error("invalid format, document not terminated", pi->str, pi->s);
+	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+	    return;
 	default:
 	    if (end <= (b + spc + (('&' == c) ? 7 : 0))) { /* extra 8 for special just in case it is sequence of bytes */
 		unsigned long	size;
@@ -682,7 +750,8 @@ read_name_token(PInfo pi) {
 	    return start;
 	case '\0':
 	    /* documents never terminate after a name token */
-	    raise_error("invalid format, document not terminated", pi->str, pi->s);
+	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+	    return 0;
 	    break; /* to avoid warnings */
 	default:
 	    break;
@@ -699,7 +768,8 @@ read_cdata(PInfo pi) {
     start = pi->s;
     end = strstr(pi->s, "]]>");
     if (end == 0) {
-	raise_error("invalid format, CDATA not terminated", pi->str, pi->s);
+	set_error(&pi->err, "invalid format, CDATA not terminated", pi->str, pi->s);
+	return;
     }
     *end = '\0';
     pi->s = end + 3;
@@ -740,19 +810,22 @@ read_quoted_value(PInfo pi) {
         value = pi->s;
         for (; *pi->s != term; pi->s++) {
             if ('\0' == *pi->s) {
-                raise_error("invalid format, document not terminated", pi->str, pi->s);
+                set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+		return 0;
             }
         }
         *pi->s = '\0';	/* terminate value */
         pi->s++;	/* move past quote */
     } else if (StrictEffort == pi->options->effort) {
-	raise_error("invalid format, expected a quote character", pi->str, pi->s);
+	set_error(&pi->err, "invalid format, expected a quote character", pi->str, pi->s);
+	return 0;
     } else if (TolerantEffort == pi->options->effort) {
         value = pi->s;
         for (; 1; pi->s++) {
 	    switch (*pi->s) {
 	    case '\0':
-                raise_error("invalid format, document not terminated", pi->str, pi->s);
+                set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+		return 0;
 	    case ' ':
 	    case '/':
 	    case '>':
@@ -772,7 +845,8 @@ read_quoted_value(PInfo pi) {
         value = pi->s;
         next_white(pi);
 	if ('\0' == *pi->s) {
-	    raise_error("invalid format, document not terminated", pi->str, pi->s);
+	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
+	    return 0;
         }
         *pi->s++ = '\0'; /* terminate value */
     }
@@ -912,8 +986,9 @@ read_coded_chars(PInfo pi, char *text) {
 		*text++ = '&';
 		return text;
 	    } else {
-		/*raise_error("Invalid encoding, need UTF-8 or UTF-16 encoding to parse &#nnnn; character sequences.", pi->str, pi->s); */
-		raise_error("Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);
+		/*set_error(&pi->err, "Invalid encoding, need UTF-8 or UTF-16 encoding to parse &#nnnn; character sequences.", pi->str, pi->s); */
+		set_error(&pi->err, "Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);
+		return 0;
 	    }
 	    pi->s = s;
 	}
@@ -994,8 +1069,9 @@ collapse_special(PInfo pi, char *str) {
 		    pi->options->rb_enc = ox_utf8_encoding;
 		    b = ucs_to_utf8_chars(b, u);
 		} else {
-		    /* raise_error("Invalid encoding, need UTF-8 or UTF-16 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);*/
-		    raise_error("Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);
+		    /* set_error(&pi->err, "Invalid encoding, need UTF-8 or UTF-16 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);*/
+		    set_error(&pi->err, "Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);
+		    return 0;
 		}
 		s = end + 1;
 	    } else {