ox 1.4.1 → 1.4.2

data/README.md

@@ -26,9 +26,10 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.4.1
+### Release 1.4.2
 
- - Empty CDATA buf found and fixed by adamvaughan on github
+ - Made Ox more tolerant when parsing invalid XML files without a prolog.
+ - DOCTYPE value was one character too long.
 
 ## <a name="description">Description</a>
 

data/ext/ox/dump.c

@@ -697,7 +697,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
                 out->w_end(out, &e);
             }
 #else
-#ifdef JRUBY
+#if (defined JRUBY || defined RBX_Qnil)
             VALUE       vars = rb_funcall2(obj, rb_intern("instance_variables"), 0, 0);
 #else
             VALUE       vars = rb_obj_instance_variables(obj);
@@ -785,7 +785,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
         out->w_end(out, &e);
         break;
     }
-#ifdef T_COMPLEX
+#if (defined T_COMPLEX && defined RCOMPLEX)
     case T_COMPLEX:
         e.type = ComplexCode;
         out->w_start(out, &e);
@@ -794,7 +794,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
         out->w_end(out, &e);
         break;
 #endif
-#ifdef T_RATIONAL
+#if (defined T_RATIONAL && defined RRATIONAL)
     case T_RATIONAL:
         e.type = RationalCode;
         out->w_start(out, &e);

data/ext/ox/gen_load.c

@@ -38,6 +38,7 @@
 #include "ox.h"
 
 static void     instruct(PInfo pi, const char *target, Attr attrs);
+static void	create_doc(PInfo pi);
 static void     create_prolog_doc(PInfo pi, const char *target, Attr attrs);
 static void     nomode_instruct(PInfo pi, const char *target, Attr attrs);
 static void     add_doctype(PInfo pi, const char *docType);
@@ -85,6 +86,20 @@ struct _ParseCallbacks   _ox_nomode_callbacks = {
 
 ParseCallbacks   ox_nomode_callbacks = &_ox_nomode_callbacks;
 
+static void
+create_doc(PInfo pi) {
+    VALUE       doc;
+    VALUE       nodes;
+
+    pi->h = pi->helpers;
+    doc = rb_obj_alloc(ox_document_clas);
+    nodes = rb_ary_new();
+    rb_ivar_set(doc, attributes_id, rb_hash_new());
+    rb_ivar_set(doc, nodes_id, nodes);
+    pi->h->obj = nodes;
+    pi->obj = doc;
+}
+
 static void
 create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
     VALUE       doc;
@@ -112,8 +127,6 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
     pi->obj = doc;
 }
 
-
-
 static void
 instruct(PInfo pi, const char *target, Attr attrs) {
     if (0 == strcmp("xml", target)) {
@@ -178,6 +191,9 @@ add_doctype(PInfo pi, const char *docType) {
     }
 #endif
     rb_ivar_set(n, value_id, s);
+    if (0 == pi->h) { // top level object
+	create_doc(pi);
+    }
     rb_ary_push(pi->h->obj, n);
 }
 
@@ -192,6 +208,9 @@ add_comment(PInfo pi, const char *comment) {
     }
 #endif
     rb_ivar_set(n, value_id, s);
+    if (0 == pi->h) { // top level object
+	create_doc(pi);
+    }
     rb_ary_push(pi->h->obj, n);
 }
 
@@ -206,6 +225,9 @@ add_cdata(PInfo pi, const char *cdata, size_t len) {
     }
 #endif
     rb_ivar_set(n, value_id, s);
+    if (0 == pi->h) { // top level object
+	create_doc(pi);
+    }
     rb_ary_push(pi->h->obj, n);
 }
 
@@ -218,6 +240,9 @@ add_text(PInfo pi, char *text, int closed) {
         rb_enc_associate(s, pi->encoding);
     }
 #endif
+    if (0 == pi->h) { // top level object
+	create_doc(pi);
+    }
     rb_ary_push(pi->h->obj, s);
 }
 

data/ext/ox/parse.c

@@ -36,18 +36,18 @@
 #include "ruby.h"
 #include "ox.h"
 
-static void     read_instruction(PInfo pi);
-static void     read_doctype(PInfo pi);
-static void     read_comment(PInfo pi);
-static void     read_element(PInfo pi);
-static void     read_text(PInfo pi);
-//static void     read_reduced_text(PInfo pi);
-static void     read_cdata(PInfo pi);
-static char*    read_name_token(PInfo pi);
-static char*    read_quoted_value(PInfo pi);
-static int      read_coded_char(PInfo pi);
-static void     next_non_white(PInfo pi);
-static int      collapse_special(char *str);
+static void	read_instruction(PInfo pi);
+static void	read_doctype(PInfo pi);
+static void	read_comment(PInfo pi);
+static void	read_element(PInfo pi);
+static void	read_text(PInfo pi);
+//static void	  read_reduced_text(PInfo pi);
+static void	read_cdata(PInfo pi);
+static char*	read_name_token(PInfo pi);
+static char*	read_quoted_value(PInfo pi);
+static int	read_coded_char(PInfo pi);
+static void	next_non_white(PInfo pi);
+static int	collapse_special(char *str);
 
 /* This XML parser is a single pass, destructive, callback parser. It is a
  * single pass parse since it only make one pass over the characters in the
@@ -80,14 +80,14 @@ next_non_white(PInfo pi) {
 
 VALUE
 parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
-    struct _PInfo       pi;
-    int                 body_read = 0;
+    struct _PInfo	pi;
+    int			body_read = 0;
 
     if (0 == xml) {
 	raise_error("Invalid arg, xml string can not be null", xml, 0);
     }
     if (DEBUG <= trace) {
-        printf("Parsing xml:\n%s\n", xml);
+	printf("Parsing xml:\n%s\n", xml);
     }
     /* initialize parse info */
     pi.str = xml;
@@ -106,10 +106,10 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
 	if ('\0' == *pi.s) {
 	    break;
 	}
-        if (body_read && 0 != endp) {
-            *endp = pi.s;
-            break;
-        }
+	if (body_read && 0 != endp) {
+	    *endp = pi.s;
+	    break;
+	}
 	if ('<' != *pi.s) {		// all top level entities start with <
 	    raise_error("invalid format, expected <", pi.str, pi.s);
 	}
@@ -142,7 +142,7 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
 	    raise_error("invalid format, document not terminated", pi.str, pi.s);
 	default:
 	    read_element(&pi);
-            body_read = 1;
+	    body_read = 1;
 	    break;
 	}
     }
@@ -153,12 +153,12 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
  */
 static void
 read_instruction(PInfo pi) {
-    struct _Attr        attrs[MAX_ATTRS + 1];
-    Attr                a = attrs;
-    char                *target;
-    char                *end;
-    char                c;
-        
+    struct _Attr	attrs[MAX_ATTRS + 1];
+    Attr		a = attrs;
+    char		*target;
+    char		*end;
+    char		c;
+	
     memset(attrs, 0, sizeof(attrs));
     target = read_name_token(pi);
     end = pi->s;
@@ -166,37 +166,37 @@ read_instruction(PInfo pi) {
     c = *pi->s;
     *end = '\0'; // terminate name
     if ('?' != c) {
-        while ('?' != *pi->s) {
-            if ('\0' == *pi->s) {
-                raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
-            }
-            next_non_white(pi);
-            a->name = read_name_token(pi);
-            end = pi->s;
-            next_non_white(pi);
-            if ('=' != *pi->s++) {
-                raise_error("invalid format, no attribute value", pi->str, pi->s);
-            }
-            *end = '\0'; // terminate name
-            // read value
-            next_non_white(pi);
-            a->value = read_quoted_value(pi);
-            a++;
-            if (MAX_ATTRS <= (a - attrs)) {
-                raise_error("too many attributes", pi->str, pi->s);
-            }
-        }
-        if ('?' == *pi->s) {
-            pi->s++;
-        }
+	while ('?' != *pi->s) {
+	    if ('\0' == *pi->s) {
+		raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+	    }
+	    next_non_white(pi);
+	    a->name = read_name_token(pi);
+	    end = pi->s;
+	    next_non_white(pi);
+	    if ('=' != *pi->s++) {
+		raise_error("invalid format, no attribute value", pi->str, pi->s);
+	    }
+	    *end = '\0'; // terminate name
+	    // read value
+	    next_non_white(pi);
+	    a->value = read_quoted_value(pi);
+	    a++;
+	    if (MAX_ATTRS <= (a - attrs)) {
+		raise_error("too many attributes", pi->str, pi->s);
+	    }
+	}
+	if ('?' == *pi->s) {
+	    pi->s++;
+	}
     } else {
-        pi->s++;
+	pi->s++;
     }
     if ('>' != *pi->s++) {
-        raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+	raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
     }
     if (0 != pi->pcb->instruct) {
-        pi->pcb->instruct(pi, target, attrs);
+	pi->pcb->instruct(pi, target, attrs);
     }
 }
 
@@ -205,7 +205,7 @@ read_instruction(PInfo pi) {
  */
 static void
 read_doctype(PInfo pi) {
-    char        *docType;
+    char	*docType;
     int		depth = 1;
     char	c;
 
@@ -220,6 +220,7 @@ read_doctype(PInfo pi) {
 	} else if ('>' == c) {
 	    depth--;
 	    if (0 == depth) {	/* done, at the end */
+		pi->s--;
 		break;
 	    }
 	}
@@ -227,7 +228,7 @@ read_doctype(PInfo pi) {
     *pi->s = '\0';
     pi->s++;
     if (0 != pi->pcb->add_doctype) {
-        pi->pcb->add_doctype(pi, docType);
+	pi->pcb->add_doctype(pi, docType);
     }
 }
 
@@ -237,8 +238,8 @@ static void
 read_comment(PInfo pi) {
     char	*end;
     char	*s;
-    char        *comment;
-    int         done = 0;
+    char	*comment;
+    int		done = 0;
     
     next_non_white(pi);
     comment = pi->s;
@@ -255,7 +256,7 @@ read_comment(PInfo pi) {
 	case '\r':
 	    break;
 	default:
-            *(s + 1) = '\0';
+	    *(s + 1) = '\0';
 	    done = 1;
 	    break;
 	}
@@ -263,7 +264,7 @@ read_comment(PInfo pi) {
     *end = '\0'; // in case the comment was blank
     pi->s = end + 3;
     if (0 != pi->pcb->add_comment) {
-        pi->pcb->add_comment(pi, comment);
+	pi->pcb->add_comment(pi, comment);
     }
 }
 
@@ -272,15 +273,15 @@ read_comment(PInfo pi) {
  */
 static void
 read_element(PInfo pi) {
-    struct _Attr        attrs[MAX_ATTRS];
-    Attr                ap = attrs;
-    char	        *name;
-    char                *ename;
-    char                *end;
-    char        	c;
-    long	        elen;
-    int 		hasChildren = 0;
-    int	        	done = 0;
+    struct _Attr	attrs[MAX_ATTRS];
+    Attr		ap = attrs;
+    char		*name;
+    char		*ename;
+    char		*end;
+    char		c;
+    long		elen;
+    int			hasChildren = 0;
+    int			done = 0;
 
     ename = read_name_token(pi);
     end = pi->s;
@@ -292,22 +293,22 @@ read_element(PInfo pi) {
 	/* empty element, no attributes and no children */
 	pi->s++;
 	if ('>' != *pi->s) {
-            printf("*** '%s'***\n", pi->s);
+	    //printf("*** '%s' ***\n", pi->s);
 	    raise_error("invalid format, element not closed", pi->str, pi->s);
 	}
 	pi->s++;	/* past > */
-        ap->name = 0;
-        pi->pcb->add_element(pi, ename, attrs, hasChildren);
-        pi->pcb->end_element(pi, ename);
+	ap->name = 0;
+	pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	pi->pcb->end_element(pi, ename);
 
 	return;
     }
     /* read attribute names until the close (/ or >) is reached */
     while (!done) {
-        if ('\0' == c) {
-            next_non_white(pi);
-            c = *pi->s;
-        }
+	if ('\0' == c) {
+	    next_non_white(pi);
+	    c = *pi->s;
+	}
 	switch (c) {
 	case '\0':
 	    raise_error("invalid format, document not terminated", pi->str, pi->s);
@@ -318,9 +319,9 @@ read_element(PInfo pi) {
 		raise_error("invalid format, element not closed", pi->str, pi->s);
 	    }
 	    pi->s++;
-            ap->name = 0;
-            pi->pcb->add_element(pi, ename, attrs, hasChildren);
-            pi->pcb->end_element(pi, ename);
+	    ap->name = 0;
+	    pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	    pi->pcb->end_element(pi, ename);
 
 	    return;
 	case '>':
@@ -328,34 +329,34 @@ read_element(PInfo pi) {
 	    pi->s++;
 	    hasChildren = 1;
 	    done = 1;
-            ap->name = 0;
-            pi->pcb->add_element(pi, ename, attrs, hasChildren);
+	    ap->name = 0;
+	    pi->pcb->add_element(pi, ename, attrs, hasChildren);
 	    break;
 	default:
 	    // Attribute name so it's an element and the attribute will be
 	    // added to it.
 	    ap->name = read_name_token(pi);
-            end = pi->s;
+	    end = pi->s;
 	    next_non_white(pi);
 	    if ('=' != *pi->s++) {
 		raise_error("invalid format, no attribute value", pi->str, pi->s);
 	    }
-            *end = '\0'; // terminate name
+	    *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((char*)ap->value)) {
-                    raise_error("invalid format, special character does not end with a semicolon", pi->str, pi->s);
-                }
-            }
-            ap++;
-            if (MAX_ATTRS <= (ap - attrs)) {
+	    if (0 != strchr(ap->value, '&')) {
+		if (0 != collapse_special((char*)ap->value)) {
+		    raise_error("invalid format, special character does not end with a semicolon", pi->str, pi->s);
+		}
+	    }
+	    ap++;
+	    if (MAX_ATTRS <= (ap - attrs)) {
 		raise_error("too many attributes", pi->str, pi->s);
-            }
+	    }
 	    break;
 	}
-        c = '\0';
+	c = '\0';
     }
     if (hasChildren) {
 	char	*start;
@@ -386,18 +387,18 @@ read_element(PInfo pi) {
 		case '/':
 		    pi->s++;
 		    name = read_name_token(pi);
-                    end = pi->s;
+		    end = pi->s;
 		    next_non_white(pi);
-                    c = *pi->s;
-                    *end = '\0';
+		    c = *pi->s;
+		    *end = '\0';
 		    if (0 != strcmp(name, ename)) {
 			raise_error("invalid format, elements overlap", pi->str, pi->s);
 		    }
 		    if ('>' != c) {
 			raise_error("invalid format, element not closed", pi->str, pi->s);
 		    }
-                    pi->s++;
-                    pi->pcb->end_element(pi, ename);
+		    pi->s++;
+		    pi->pcb->end_element(pi, ename);
 		    return;
 		case '\0':
 		    raise_error("invalid format, document not terminated", pi->str, pi->s);
@@ -418,7 +419,7 @@ read_element(PInfo pi) {
 		    '>' == *(pi->s + elen + 2)) {
 		    // close tag after text so treat as a value
 		    pi->s += elen + 3;
-                    pi->pcb->end_element(pi, ename);
+		    pi->pcb->end_element(pi, ename);
 		    return;
 		}
 	    }
@@ -428,9 +429,9 @@ read_element(PInfo pi) {
 
 static void
 read_text(PInfo pi) {
-    char        buf[MAX_TEXT_LEN];
+    char	buf[MAX_TEXT_LEN];
     char	*b = buf;
-    char        *alloc_buf = 0;
+    char	*alloc_buf = 0;
     char	*end = b + sizeof(buf) - 2;
     char	c;
     int		done = 0;
@@ -449,25 +450,25 @@ read_text(PInfo pi) {
 		c = read_coded_char(pi);
 	    }
 	    if (end <= b) {
-                unsigned long   size;
-                
-                if (0 == alloc_buf) {
-                    size = sizeof(buf) * 2;
-                    if (0 == (alloc_buf = (char*)malloc(size))) {
-                        raise_error("text too long", pi->str, pi->s);
-                    }
-                    memcpy(alloc_buf, buf, b - buf);
-                    b = alloc_buf + (b - buf);
-                } else {
-                    unsigned long       pos = b - alloc_buf;
-
-                    size = (end - alloc_buf) * 2;
-                    if (0 == (alloc_buf = (char*)realloc(alloc_buf, size))) {
-                        raise_error("text too long", pi->str, pi->s);
-                    }
-                    b = alloc_buf + pos;
-                }
-                end = alloc_buf + size - 2;
+		unsigned long	size;
+		
+		if (0 == alloc_buf) {
+		    size = sizeof(buf) * 2;
+		    if (0 == (alloc_buf = (char*)malloc(size))) {
+			raise_error("text too long", pi->str, pi->s);
+		    }
+		    memcpy(alloc_buf, buf, b - buf);
+		    b = alloc_buf + (b - buf);
+		} else {
+		    unsigned long	pos = b - alloc_buf;
+
+		    size = (end - alloc_buf) * 2;
+		    if (0 == (alloc_buf = (char*)realloc(alloc_buf, size))) {
+			raise_error("text too long", pi->str, pi->s);
+		    }
+		    b = alloc_buf + pos;
+		}
+		end = alloc_buf + size - 2;
 	    }
 	    *b++ = c;
 	    break;
@@ -475,19 +476,19 @@ read_text(PInfo pi) {
     }
     *b = '\0';
     if (0 != alloc_buf) {
-        pi->pcb->add_text(pi, alloc_buf, ('/' == *(pi->s + 1)));
-        free(alloc_buf);
+	pi->pcb->add_text(pi, alloc_buf, ('/' == *(pi->s + 1)));
+	free(alloc_buf);
     } else {
-        pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
+	pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
     }
 }
 
 #if 0
 static void
 read_reduced_text(PInfo pi) {
-    char        buf[MAX_TEXT_LEN];
+    char	buf[MAX_TEXT_LEN];
     char	*b = buf;
-    char        *alloc_buf = 0;
+    char	*alloc_buf = 0;
     char	*end = b + sizeof(buf) - 2;
     char	c;
     int		spc = 0;
@@ -514,25 +515,25 @@ read_reduced_text(PInfo pi) {
 		c = read_coded_char(pi);
 	    }
 	    if (end <= b + spc) {
-                unsigned long   size;
-                
-                if (0 == alloc_buf) {
-                    size = sizeof(buf) * 2;
-                    if (0 == (alloc_buf = (char*)malloc(size))) {
-                        raise_error("text too long", pi->str, pi->s);
-                    }
-                    memcpy(alloc_buf, buf, b - buf);
-                    b = alloc_buf + (b - buf);
-                } else {
-                    unsigned long       pos = b - alloc_buf;
-
-                    size = (end - alloc_buf) * 2;
-                    if (0 == (alloc_buf = (char*)realloc(alloc_buf, size))) {
-                        raise_error("text too long", pi->str, pi->s);
-                    }
-                    b = alloc_buf + pos;
-                }
-                end = alloc_buf + size - 2;
+		unsigned long	size;
+		
+		if (0 == alloc_buf) {
+		    size = sizeof(buf) * 2;
+		    if (0 == (alloc_buf = (char*)malloc(size))) {
+			raise_error("text too long", pi->str, pi->s);
+		    }
+		    memcpy(alloc_buf, buf, b - buf);
+		    b = alloc_buf + (b - buf);
+		} else {
+		    unsigned long	pos = b - alloc_buf;
+
+		    size = (end - alloc_buf) * 2;
+		    if (0 == (alloc_buf = (char*)realloc(alloc_buf, size))) {
+			raise_error("text too long", pi->str, pi->s);
+		    }
+		    b = alloc_buf + pos;
+		}
+		end = alloc_buf + size - 2;
 	    }
 	    if (spc) {
 		*b++ = ' ';
@@ -544,17 +545,17 @@ read_reduced_text(PInfo pi) {
     }
     *b = '\0';
     if (0 != alloc_buf) {
-        pi->pcb->add_text(pi, alloc_buf, ('/' == *(pi->s + 1)));
-        free(alloc_buf);
+	pi->pcb->add_text(pi, alloc_buf, ('/' == *(pi->s + 1)));
+	free(alloc_buf);
     } else {
-        pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
+	pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
     }
 }
 #endif
 
 static char*
 read_name_token(PInfo pi) {
-    char        *start;
+    char	*start;
 
     next_non_white(pi);
     start = pi->s;
@@ -571,9 +572,9 @@ read_name_token(PInfo pi) {
 	case '\r':
 	    return start;
 	case '\0':
-            // documents never terminate after a name token
+	    // documents never terminate after a name token
 	    raise_error("invalid format, document not terminated", pi->str, pi->s);
-            break; // to avoid warnings
+	    break; // to avoid warnings
 	default:
 	    break;
 	}
@@ -584,7 +585,7 @@ read_name_token(PInfo pi) {
 static void
 read_cdata(PInfo pi) {
     char	*start;
-    char        *end;
+    char	*end;
 
     start = pi->s;
     end = strstr(pi->s, "]]>");
@@ -594,7 +595,7 @@ read_cdata(PInfo pi) {
     *end = '\0';
     pi->s = end + 3;
     if (0 != pi->pcb->add_cdata) {
-        pi->pcb->add_cdata(pi, start, end - start);
+	pi->pcb->add_cdata(pi, start, end - start);
     }
 }
 
@@ -603,7 +604,7 @@ read_cdata(PInfo pi) {
  */
 static char*
 read_quoted_value(PInfo pi) {
-    char        *value;
+    char	*value;
     
     if ('"' != *pi->s) {
 	raise_error("invalid format, expected a quote character", pi->str, pi->s);
@@ -613,10 +614,10 @@ read_quoted_value(PInfo pi) {
     for (; *pi->s != '"'; pi->s++) {
 	if ('\0' == *pi->s) {
 	    raise_error("invalid format, document not terminated", pi->str, pi->s);
-        }
+	}
     }
     *pi->s = '\0'; // terminate value
-    pi->s++;       // move past quote
+    pi->s++;	   // move past quote
 
     return value;
 }
@@ -672,49 +673,49 @@ read_coded_char(PInfo pi) {
 
 static int
 collapse_special(char *str) {
-    char        *s = str;
-    char        *b = str;
+    char	*s = str;
+    char	*b = str;
 
     while ('\0' != *s) {
-        if ('&' == *s) {
-            int         c;
-            char        *end;
-            
-            s++;
-            if ('#' == *s) {
-                c = (int)strtol(s, &end, 10);
-                if (';' != *end) {
-                    return EDOM;
-                }
-                s = end + 1;
-            } else if (0 == strncasecmp(s, "lt;", 3)) {
-                c = '<';
-                s += 3;
-            } else if (0 == strncasecmp(s, "gt;", 3)) {
-                c = '>';
-                s += 3;
-            } else if (0 == strncasecmp(s, "amp;", 4)) {
-                c = '&';
-                s += 4;
-            } else if (0 == strncasecmp(s, "quot;", 5)) {
-                c = '"';
-                s += 5;
-            } else if (0 == strncasecmp(s, "apos;", 5)) {
-                c = '\'';
-                s += 5;
-            } else {
-                c = '?';
-                while (';' != *s++) {
-                    if ('\0' == *s) {
-                        return EDOM;
-                    }
-                }
-                s++;
-            }
-            *b++ = (char)c;
-        } else {
-            *b++ = *s++;
-        }
+	if ('&' == *s) {
+	    int		c;
+	    char	*end;
+	    
+	    s++;
+	    if ('#' == *s) {
+		c = (int)strtol(s, &end, 10);
+		if (';' != *end) {
+		    return EDOM;
+		}
+		s = end + 1;
+	    } else if (0 == strncasecmp(s, "lt;", 3)) {
+		c = '<';
+		s += 3;
+	    } else if (0 == strncasecmp(s, "gt;", 3)) {
+		c = '>';
+		s += 3;
+	    } else if (0 == strncasecmp(s, "amp;", 4)) {
+		c = '&';
+		s += 4;
+	    } else if (0 == strncasecmp(s, "quot;", 5)) {
+		c = '"';
+		s += 5;
+	    } else if (0 == strncasecmp(s, "apos;", 5)) {
+		c = '\'';
+		s += 5;
+	    } else {
+		c = '?';
+		while (';' != *s++) {
+		    if ('\0' == *s) {
+			return EDOM;
+		    }
+		}
+		s++;
+	    }
+	    *b++ = (char)c;
+	} else {
+	    *b++ = *s++;
+	}
     }
     *b = '\0';
 

data/lib/ox/bag.rb

@@ -16,10 +16,6 @@ module Ox
     def initialize(args={ })
       args.each do |k,v|
         self.instance_variable_set(k, v)
-        m = k.to_s[1..-1].to_sym
-        unless respond_to?(m)
-          self.class.define_get(m, k)
-        end
       end
     end
 
@@ -28,6 +24,7 @@ module Ox
     # @return [Boolean] true for any method that matches an instance
     #                   variable reader, otherwise false.
     def respond_to?(m)
+      return true if super
       at_m = ('@' + m.to_s).to_sym
       instance_variables.include?(at_m)
     end

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module. 
-  VERSION = '1.4.1'
+  VERSION = '1.4.2'
 end

data/test/bench.rb

@@ -13,7 +13,7 @@
 # unpack: marshal                  0.609927
 # unpack: ox                       0.287053
 
-require 'msgpack'
+#require 'msgpack'
 require 'json'
 require 'ox'
 
@@ -32,14 +32,14 @@ end
 
 def bench_all(title, iter, obj)
   puts "\n#{title} Packing"
-  bench('pack: message pack', iter) { MessagePack.pack(obj) }
+#  bench('pack: message pack', iter) { MessagePack.pack(obj) }
   bench('pack: marshall', iter) { Marshal.dump(obj) }
   bench('pack: json', iter) { JSON.dump(obj) }
   bench('pack: ox', iter) { Ox.dump(obj) }
 
   puts "\n#{title} Unpacking"
-  mp_obj = MessagePack.pack(obj)
-  bench('unpack: message pack', iter) { MessagePack.unpack(mp_obj) }
+#  mp_obj = MessagePack.pack(obj)
+#  bench('unpack: message pack', iter) { MessagePack.unpack(mp_obj) }
   mars_obj = Marshal.dump(obj)
   bench('unpack: marshal', iter) { Marshal.load(mars_obj) }
   json_obj = JSON.dump(obj)

data/test/big.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+if __FILE__ == $0
+  while (i = ARGV.index('-I'))
+    x,path = ARGV.slice!(i, 2)
+    $: << path
+  end
+end
+
+require 'ox'
+
+def dump(cnt = 10000)
+  h = { }
+  cnt.times do |i|
+    h[i] = [i * 2, "this is #{i}"]
+  end
+  xml = Ox.dump(h)
+  puts "size: #{xml.size}"
+end
+
+dump(200000)

data/test/bug3.rb

@@ -3,19 +3,21 @@
 $: << '../lib'
 $: << '../ext'
 
+if __FILE__ == $0
+  if (i = ARGV.index('-I'))
+    x,path = ARGV.slice!(i, 2)
+    $: << path
+  end
+end
+
 require 'ox'
 
-def name_it()
-  begin
-    "x".foo
-  rescue Exception => e
-    #puts e.message
-    xml = Ox.dump(e, effort: :tolerant)
-    puts xml
-    o = Ox.load(xml, mode: :object)
-    puts o.message
-    puts Ox.dump(e)
+def dump(cnt = 100000)
+  cnt.times do |i|
+    xml = Ox.dump([:inc, 1])
+    #puts xml
+    
   end
 end
 
-name_it()
+dump()

data/test/bug4.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+require 'ox'
+
+#xml = File.read('bug4.xml')
+xml = File.read('bug4.xml')
+
+doc = Ox.parse(xml)

data/test/func.rb

@@ -216,6 +216,12 @@ class Func < ::Test::Unit::TestCase
     assert_equal("<!DOCTYPE s SYSTEM \"ox.dtd\">\n<s>test</s>\n", xml)
   end
 
+  def test_lone_dtd
+    xml = "<!DOCTYPE html>" # not really a valid xml but should pass anyway
+    doc = Ox.parse(xml)
+    assert_equal('html', doc.nodes[0].value)
+  end
+
   def test_class
     dump_and_load(Bag, false)
   end

metadata

@@ -1,28 +1,24 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ox
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 1.4.2
   prerelease: 
-  version: 1.4.1
 platform: ruby
-authors: 
+authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-16 00:00:00 +09:00
-default_executable: 
+date: 2011-12-03 00:00:00.000000000Z
 dependencies: []
-
 description: A fast XML parser and object serializer that uses only standard C lib.
 email: peter@ohler.com
 executables: []
-
-extensions: 
+extensions:
 - ext/ox/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
-files: 
+files:
 - lib/ox/bag.rb
 - lib/ox/cdata.rb
 - lib/ox/comment.rb
@@ -51,9 +47,11 @@ files:
 - ext/ox/parse.c
 - ext/ox/sax.c
 - test/bench.rb
+- test/big.rb
 - test/bug1.rb
 - test/bug2.rb
 - test/bug3.rb
+- test/bug4.rb
 - test/cache16_test.rb
 - test/cache8_test.rb
 - test/cache_test.rb
@@ -81,41 +79,36 @@ files:
 - test/perf_sax.rb
 - test/perf_write.rb
 - test/sample.rb
-- test/sax_example.rb
 - test/sax_test.rb
 - test/test.rb
 - test/Sample.graffle
 - LICENSE
 - README.md
-has_rdoc: true
 homepage: https://github.com/ohler55/ox
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.md
-require_paths: 
+require_paths:
 - lib
 - ext
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: ox
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A fast XML parser and object serializer.
 test_files: []
-

data/test/sax_example.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby -wW1
-
-$: << '../lib'
-$: << '../ext'
-
-require 'stringio'
-require 'ox'
-
-class Sample < ::Ox::Sax
-  def start_element(name); puts "start: #{name}"; end
-  def end_element(name); puts "end: #{name}"; end
-  def attr(name, value); puts "  #{name} => #{value}"; end
-  def text(value); puts "text #{value}"; end
-end
-
-io = StringIO.new(%{
-<top name="sample">
-  <middle name="second">
-    <bottom name="third"/>
-  </middle>
-</top>
-})
-
-handler = Sample.new()
-Ox.sax_parse(handler, io)
-
-# outputs
-# start: top
-#   name => sample
-# start: middle
-#   name => second
-# start: bottom
-#   name => third
-# end: bottom
-# end: middle
-# end: top
-