ox 1.7.1 → 1.8.0

data/README.md

@@ -34,6 +34,10 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
+### Release 1.8.0
+
+ - Added more complete support for processing instructions in both the generic parser and in the sax parser. This change includes and additional sax handler callback for the end of the instruction processing.
+
 ### Release 1.7.1
 
  - Pulled in sharpyfox's changes to make Ox with with Windows. (issue #24)

data/ext/ox/dump.c

@@ -77,6 +77,7 @@ static void     dump_first_obj(VALUE obj, Out out);
 static void     dump_obj(ID aid, VALUE obj, unsigned int depth, Out out);
 static void     dump_gen_doc(VALUE obj, unsigned int depth, Out out);
 static void     dump_gen_element(VALUE obj, unsigned int depth, Out out);
+static void	dump_gen_instruct(VALUE obj, unsigned int depth, Out out);
 static int      dump_gen_attr(VALUE key, VALUE value, Out out);
 static int      dump_gen_nodes(VALUE obj, unsigned int depth, Out out);
 static void     dump_gen_val_node(VALUE obj, unsigned int depth,
@@ -1064,6 +1065,40 @@ dump_gen_element(VALUE obj, unsigned int depth, Out out) {
     *out->cur = '\0';
 }
 
+static void
+dump_gen_instruct(VALUE obj, unsigned int depth, Out out) {
+    VALUE	rname = rb_attr_get(obj, ox_at_value_id);
+    VALUE	attrs = rb_attr_get(obj, ox_attributes_id);
+    VALUE	rcontent = rb_attr_get(obj, ox_at_content_id);
+    const char	*name = StringValuePtr(rname);
+    const char	*content = 0;
+    long	nlen = RSTRING_LEN(rname);
+    long	clen = 0;
+    size_t	size;
+    
+    if (T_STRING == rb_type(rcontent)) {
+	content = StringValuePtr(rcontent);
+	clen = RSTRING_LEN(rcontent);
+	size = 4 + nlen + clen;
+    } else {
+	size = 4 + nlen;
+    }
+    if (out->end - out->cur <= (long)size) {
+        grow(out, size);
+    }
+    *out->cur++ = '<';
+    *out->cur++ = '?';
+    fill_value(out, name, nlen);
+    if (0 != content) {
+	fill_value(out, content, clen);
+    } else if (Qnil != attrs) {
+        rb_hash_foreach(attrs, dump_gen_attr, (VALUE)out);
+    }
+    *out->cur++ = '?';
+    *out->cur++ = '>';
+    *out->cur = '\0';
+}
+
 static int
 dump_gen_nodes(VALUE obj, unsigned int depth, Out out) {
     long        cnt = RARRAY_LEN(obj);
@@ -1078,6 +1113,8 @@ dump_gen_nodes(VALUE obj, unsigned int depth, Out out) {
             clas = rb_obj_class(*np);
             if (ox_element_clas == clas) {
                 dump_gen_element(*np, d2, out);
+	    } else if (ox_instruct_clas == clas) {
+                dump_gen_instruct(*np, d2, out);
             } else if (rb_cString == clas) {
                 dump_str_value(out, StringValuePtr(*np), RSTRING_LEN(*np));
                 indent_needed = (1 == cnt) ? 0 : 1;

data/ext/ox/gen_load.c

@@ -37,16 +37,17 @@
 #include "ruby.h"
 #include "ox.h"
 
-static void     instruct(PInfo pi, const char *target, Attr attrs);
+static void     instruct(PInfo pi, const char *target, Attr attrs, const char *content);
 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     nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *content);
 static void     add_doctype(PInfo pi, const char *docType);
 static void     add_comment(PInfo pi, const char *comment);
 static void     add_cdata(PInfo pi, const char *cdata, size_t len);
 static void     add_text(PInfo pi, char *text, int closed);
 static void     add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren);
 static void     end_element(PInfo pi, const char *ename);
+static void	add_instruct(PInfo pi, const char *name, Attr attrs, const char *content);
 
 extern ParseCallbacks   ox_obj_callbacks;
 
@@ -152,7 +153,7 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 }
 
 static void
-instruct(PInfo pi, const char *target, Attr attrs) {
+instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
         create_prolog_doc(pi, target, attrs);
     } else if (0 == strcmp("ox", target)) {
@@ -165,14 +166,12 @@ instruct(PInfo pi, const char *target, Attr attrs) {
             /* ignore other instructions */
         }
     } else {
-        if (TRACE <= pi->options->trace) {
-            printf("Processing instruction %s ignored.\n", target);
-        }
+	add_instruct(pi, target, attrs, content);
     }
 }
 
 static void
-nomode_instruct(PInfo pi, const char *target, Attr attrs) {
+nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
         create_prolog_doc(pi, target, attrs);
     } else if (0 == strcmp("ox", target)) {
@@ -344,3 +343,71 @@ end_element(PInfo pi, const char *ename) {
         pi->h--;
     }
 }
+
+static void
+add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
+    VALUE       inst;
+    VALUE       s = rb_str_new2(name);
+    VALUE       c = Qnil;
+
+    if (0 != content) {
+	c = rb_str_new2(content);
+    }
+#if HAS_ENCODING_SUPPORT
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+	if (0 != content) {
+	    rb_enc_associate(c, pi->options->rb_enc);
+	}
+    }
+#endif
+    inst = rb_obj_alloc(ox_instruct_clas);
+    rb_ivar_set(inst, ox_at_value_id, s);
+    if (0 != content) {
+	rb_ivar_set(inst, ox_at_content_id, c);
+    } else if (0 != attrs->name) {
+        VALUE   ah = rb_hash_new();
+        
+        for (; 0 != attrs->name; attrs++) {
+            VALUE   sym;
+            VALUE   *slot;
+
+	    if (Yes == pi->options->sym_keys) {
+		if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot))) {
+#if HAS_ENCODING_SUPPORT
+		    if (0 != pi->options->rb_enc) {
+			VALUE	rstr = rb_str_new2(attrs->name);
+
+			rb_enc_associate(rstr, pi->options->rb_enc);
+			sym = rb_funcall(rstr, ox_to_sym_id, 0);
+		    } else {
+			sym = ID2SYM(rb_intern(attrs->name));
+		    }
+#else
+		    sym = ID2SYM(rb_intern(attrs->name));
+#endif
+		    *slot = sym;
+		}
+	    } else {
+		sym = rb_str_new2(attrs->name);
+#if HAS_ENCODING_SUPPORT
+		if (0 != pi->options->rb_enc) {
+		    rb_enc_associate(sym, pi->options->rb_enc);
+		}
+#endif
+	    }
+            s = rb_str_new2(attrs->value);
+#if HAS_ENCODING_SUPPORT
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(s, pi->options->rb_enc);
+            }
+#endif
+            rb_hash_aset(ah, sym, s);
+        }
+        rb_ivar_set(inst, ox_attributes_id, ah);
+    }
+    if (0 == pi->h) { /* top level object */
+	create_doc(pi);
+    }
+    rb_ary_push(pi->h->obj, inst);
+}

data/ext/ox/obj_load.c

@@ -39,7 +39,7 @@
 #include "base64.h"
 #include "ox.h"
 
-static void     instruct(PInfo pi, const char *target, Attr attrs);
+static void     instruct(PInfo pi, const char *target, Attr attrs, const char *content);
 static void     add_text(PInfo pi, char *text, int closed);
 static void     add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren);
 static void     end_element(PInfo pi, const char *ename);
@@ -394,7 +394,7 @@ parse_regexp(const char *text) {
 }
 
 static void
-instruct(PInfo pi, const char *target, Attr attrs) {
+instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
 #if HAS_ENCODING_SUPPORT
         for (; 0 != attrs->name; attrs++) {

data/ext/ox/ox.c

@@ -48,6 +48,7 @@ void Init_ox();
 
 VALUE	 Ox = Qnil;
 
+ID	ox_at_content_id;
 ID	ox_at_id;
 ID	ox_at_value_id;
 ID	ox_attr_id;
@@ -60,6 +61,7 @@ ID	ox_den_id;
 ID	ox_doctype_id;
 ID	ox_end_element_id;
 ID	ox_end_id;
+ID	ox_end_instruct_id;
 ID	ox_error_id;
 ID	ox_excl_id;
 ID	ox_external_encoding_id;
@@ -92,16 +94,17 @@ VALUE	ox_encoding_sym;
 VALUE	ox_empty_string;
 VALUE	ox_zero_fixnum;
 
+VALUE	ox_bag_clas;
 VALUE	ox_cdata_clas;
 VALUE	ox_comment_clas;
+VALUE	ox_date_class;
 VALUE	ox_doctype_clas;
 VALUE	ox_document_clas;
 VALUE	ox_element_clas;
-VALUE	ox_bag_clas;
+VALUE	ox_instruct_clas;
+VALUE	ox_stringio_class;
 VALUE	ox_struct_class;
 VALUE	ox_time_class;
-VALUE	ox_date_class;
-VALUE	ox_stringio_class;
 
 Cache	ox_symbol_cache = 0;
 Cache	ox_class_cache = 0;
@@ -780,11 +783,13 @@ void Init_ox() {
     ox_beg_id = rb_intern("@beg");
     ox_cdata_id = rb_intern("cdata");
     ox_comment_id = rb_intern("comment");
+    ox_at_content_id = rb_intern("@content");
     ox_den_id = rb_intern("@den");
     ox_doctype_id = rb_intern("doctype");
     ox_external_encoding_id = rb_intern("external_encoding");
     ox_end_element_id = rb_intern("end_element");
     ox_end_id = rb_intern("@end");
+    ox_end_instruct_id = rb_intern("end_instruct");
     ox_error_id = rb_intern("error");
     ox_excl_id = rb_intern("@excl");
     ox_fileno_id = rb_intern("fileno");
@@ -843,6 +848,7 @@ void Init_ox() {
 
     ox_document_clas = rb_const_get_at(Ox, rb_intern("Document"));
     ox_element_clas = rb_const_get_at(Ox, rb_intern("Element"));
+    ox_instruct_clas = rb_const_get_at(Ox, rb_intern("Instruct"));
     ox_comment_clas = rb_const_get_at(Ox, rb_intern("Comment"));
     ox_doctype_clas = rb_const_get_at(Ox, rb_intern("DocType"));
     ox_cdata_clas = rb_const_get_at(Ox, rb_intern("CData"));

data/ext/ox/ox.h

@@ -158,7 +158,7 @@ typedef struct _Helper {
 typedef struct _PInfo	*PInfo;
 
 typedef struct _ParseCallbacks {
-    void	(*instruct)(PInfo pi, const char *target, Attr attrs);
+    void	(*instruct)(PInfo pi, const char *target, Attr attrs, const char *content);
     void	(*add_doctype)(PInfo pi, const char *docType);
     void	(*add_comment)(PInfo pi, const char *comment);
     void	(*add_cdata)(PInfo pi, const char *cdata, size_t len);
@@ -220,6 +220,7 @@ extern struct _Options	ox_default_options;
 
 extern VALUE	Ox;
 
+extern ID	ox_at_content_id;
 extern ID	ox_at_id;
 extern ID	ox_at_value_id;
 extern ID	ox_attr_id;
@@ -232,6 +233,7 @@ extern ID	ox_den_id;
 extern ID	ox_doctype_id;
 extern ID	ox_end_element_id;
 extern ID	ox_end_id;
+extern ID	ox_end_instruct_id;
 extern ID	ox_error_id;
 extern ID	ox_excl_id;
 extern ID	ox_external_encoding_id;
@@ -275,6 +277,7 @@ extern VALUE	ox_zero_fixnum;
 
 extern VALUE	ox_document_clas;
 extern VALUE	ox_element_clas;
+extern VALUE	ox_instruct_clas;
 extern VALUE	ox_bag_clas;
 extern VALUE	ox_comment_clas;
 extern VALUE	ox_doctype_clas;

data/ext/ox/parse.c

@@ -68,7 +68,7 @@ static int	collapse_special(PInfo pi, char *str);
 inline static void
 next_non_white(PInfo pi) {
     for (; 1; pi->s++) {
-	switch(*pi->s) {
+	switch (*pi->s) {
 	case ' ':
 	case '\t':
 	case '\f':
@@ -84,7 +84,7 @@ next_non_white(PInfo pi) {
 inline static void
 next_white(PInfo pi) {
     for (; 1; pi->s++) {
-	switch(*pi->s) {
+	switch (*pi->s) {
 	case ' ':
 	case '\t':
 	case '\f':
@@ -131,7 +131,7 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
 	}
 	pi.s++;		/* past < */
 	switch (*pi.s) {
-	case '?':	/* prolog */
+	case '?':	/* processing instruction */
 	    pi.s++;
 	    read_instruction(&pi);
 	    break;
@@ -165,19 +165,47 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options) {
     return pi.obj;
 }
 
+static char*
+gather_content(const char *src, char *content, size_t len) {
+    for (; 0 < len; src++, content++, len--) {
+	switch (*src) {
+	case '?':
+	    if ('>' == *(src + 1)) {
+		*content = '\0';
+		return (char*)(src + 1);
+	    }
+	    *content = *src;
+	    break;
+	case '\0':
+	    return 0;
+	default:
+	    *content = *src;
+	    break;
+	}
+    }
+    return 0;
+}
+
 /* Entered after the "<?" sequence. Ready to read the rest.
  */
 static void
 read_instruction(PInfo pi) {
+    char		content[1024];
     struct _Attr	attrs[MAX_ATTRS + 1];
     Attr		a = attrs;
     char		*target;
     char		*end;
     char		c;
-	
+    char		*cend;
+    int			attrs_ok = 1;
+
+    *content = '\0';
     memset(attrs, 0, sizeof(attrs));
     target = read_name_token(pi);
     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);
+    }
     next_non_white(pi);
     c = *pi->s;
     *end = '\0'; /* terminate name */
@@ -191,7 +219,8 @@ read_instruction(PInfo pi) {
 	    end = pi->s;
 	    next_non_white(pi);
 	    if ('=' != *pi->s++) {
-		raise_error("invalid format, no attribute value", pi->str, pi->s);
+		attrs_ok = 0;
+		break;
 	    }
 	    *end = '\0'; /* terminate name */
 	    /* read value */
@@ -199,7 +228,8 @@ read_instruction(PInfo pi) {
 	    a->value = read_quoted_value(pi);
 	    a++;
 	    if (MAX_ATTRS <= (a - attrs)) {
-		raise_error("too many attributes", pi->str, pi->s);
+		attrs_ok = 0;
+		break;
 	    }
 	    next_non_white(pi);
 	}
@@ -209,11 +239,19 @@ read_instruction(PInfo pi) {
     } else {
 	pi->s++;
     }
-    if ('>' != *pi->s++) {
-	raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+    if (attrs_ok) {
+	if ('>' != *pi->s++) {
+	    raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+	}
+    } else {
+	pi->s = cend + 1;
     }
     if (0 != pi->pcb->instruct) {
-	pi->pcb->instruct(pi, target, attrs);
+	if (attrs_ok) {
+	    pi->pcb->instruct(pi, target, attrs, 0);
+	} else {
+	    pi->pcb->instruct(pi, target, attrs, content);
+	}
     }
 }
 
@@ -404,6 +442,10 @@ read_element(PInfo pi) {
 			raise_error("invalid format, invalid comment or CDATA format", pi->str, pi->s);
 		    }
 		    break;
+		case '?':	/* processing instruction */
+		    pi->s++;
+		    read_instruction(pi);
+		    break;
 		case '/':
 		    slash = pi->s;
 		    pi->s++;

data/ext/ox/sax.c

@@ -61,6 +61,7 @@ typedef struct _SaxDrive {
 	const char	*in_str;
     };
     int         has_instruct;
+    int         has_end_instruct;
     int         has_attr;
     int         has_attr_value;
     int         has_doctype;
@@ -76,34 +77,34 @@ typedef struct _SaxDrive {
 #endif
 } *SaxDrive;
 
-static void     sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert);
-static void     sax_drive_cleanup(SaxDrive dr);
-static int      sax_drive_read(SaxDrive dr);
-static void     sax_drive_error(SaxDrive dr, const char *msg, int critical);
-
-static int      read_children(SaxDrive dr, int first);
-static int      read_instruction(SaxDrive dr);
-static int      read_doctype(SaxDrive dr);
-static int      read_cdata(SaxDrive dr);
-static int      read_comment(SaxDrive dr);
-static int      read_element(SaxDrive dr);
-static int      read_text(SaxDrive dr);
-static int      read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml);
-static char     read_name_token(SaxDrive dr);
-static int      read_quoted_value(SaxDrive dr);
-static int      collapse_special(char *str);
-
-static VALUE	rescue_cb(VALUE rdr, VALUE err);
-static VALUE    io_cb(VALUE rdr);
-static VALUE    partial_io_cb(VALUE rdr);
-static int      read_from_io(SaxDrive dr);
+static void		sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert);
+static void		sax_drive_cleanup(SaxDrive dr);
+static int		sax_drive_read(SaxDrive dr);
+static void		sax_drive_error(SaxDrive dr, const char *msg, int critical);
+
+static int		read_children(SaxDrive dr, int first);
+static int		read_instruction(SaxDrive dr);
+static int		read_doctype(SaxDrive dr);
+static int		read_cdata(SaxDrive dr);
+static int		read_comment(SaxDrive dr);
+static int		read_element(SaxDrive dr);
+static int		read_text(SaxDrive dr);
+static const char*	read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml);
+static char		read_name_token(SaxDrive dr);
+static int		read_quoted_value(SaxDrive dr);
+static int		collapse_special(char *str);
+
+static VALUE		rescue_cb(VALUE rdr, VALUE err);
+static VALUE		io_cb(VALUE rdr);
+static VALUE		partial_io_cb(VALUE rdr);
+static int		read_from_io(SaxDrive dr);
 #ifndef JRUBY_RUBY
-static int      read_from_fd(SaxDrive dr);
+static int		read_from_fd(SaxDrive dr);
 #endif
-static int      read_from_io_partial(SaxDrive dr);
-static int      read_from_str(SaxDrive dr);
+static int		read_from_io_partial(SaxDrive dr);
+static int		read_from_str(SaxDrive dr);
 
-static VALUE	sax_value_class;
+static VALUE		sax_value_class;
 
 /* This is only for CentOS 5.4 with Ruby 1.9.3-p0 and for OS X 10.6. */
 #ifdef NEEDS_STPCPY
@@ -227,6 +228,7 @@ ox_sax_parse(VALUE handler, VALUE io, int convert) {
 #if 0
     printf("*** sax_parse with these flags\n");
     printf("    has_instruct = %s\n", dr.has_instruct ? "true" : "false");
+    printf("    has_end_instruct = %s\n", dr.has_end_instruct ? "true" : "false");
     printf("    has_attr = %s\n", dr.has_attr ? "true" : "false");
     printf("    has_attr_value = %s\n", dr.has_attr_value ? "true" : "false");
     printf("    has_doctype = %s\n", dr.has_doctype ? "true" : "false");
@@ -311,6 +313,7 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
     rb_gc_register_address(&dr->value_obj);
     dr->convert_special = convert;
     dr->has_instruct = respond_to(handler, ox_instruct_id);
+    dr->has_end_instruct = respond_to(handler, ox_end_instruct_id);
     dr->has_attr = respond_to(handler, ox_attr_id);
     dr->has_attr_value = respond_to(handler, ox_attr_value_id);
     dr->has_doctype = respond_to(handler, ox_doctype_id);
@@ -444,9 +447,6 @@ read_children(SaxDrive dr, int first) {
         c = sax_drive_get(dr);
 	switch (c) {
 	case '?': /* instructions (xml or otherwise) */
-            if (!first || element_read || doctype_read) {
-                sax_drive_error(dr, "invalid format, instruction must come before elements", 0);
-            }
 	    err = read_instruction(dr);
 	    break;
 	case '!': /* comment or doctype */
@@ -504,28 +504,88 @@ read_children(SaxDrive dr, int first) {
     return err;
 }
 
+static void
+read_content(SaxDrive dr, char *content, size_t len) {
+    char	c;
+    char	*end = content + len;
+
+    while ('\0' != (c = sax_drive_get(dr))) {
+	if (end < content) {
+	    sax_drive_error(dr, "processing instruction content too large", 1);
+	}
+	if ('?' == c) {
+	    if ('\0' == (c = sax_drive_get(dr))) {
+		sax_drive_error(dr, "invalid format, document not terminated", 1);
+	    }
+	    if ('>' == c) {
+		*content = '\0';
+		return;
+	    } else {
+		*content++ = c;
+	    }
+	} else {
+	    *content++ = c;
+	}
+    }
+    *content = '\0';
+}
+
 /* Entered after the "<?" sequence. Ready to read the rest.
  */
 static int
 read_instruction(SaxDrive dr) {
+    char	content[1024];
     char        c;
+    char	*cend;
+    const char	*err;
+    VALUE	target = Qnil;
 
     if ('\0' == (c = read_name_token(dr))) {
         return -1;
     }
+    if (dr->has_instruct || dr->has_end_instruct) {
+	target = rb_str_new2(dr->str);
+    }
     if (dr->has_instruct) {
         VALUE       args[1];
 
-        args[0] = rb_str_new2(dr->str);
+        args[0] = target;
         rb_funcall2(dr->handler, ox_instruct_id, 1, args);
     }
-    if (0 != read_attrs(dr, c, '?', '?', (0 == strcmp("xml", dr->str)))) {
-        return -1;
+    dr->str = dr->cur; /* make sure the start doesn't get compacted out */
+    read_content(dr, content, sizeof(content) - 1);
+    cend = dr->cur;
+    dr->cur = dr->str;
+    if (0 != (err = read_attrs(dr, c, '?', '?', (0 == strcmp("xml", dr->str))))) {
+	if (dr->has_text) {
+	    VALUE   args[1];
+
+	    if (dr->convert_special) {
+		if (0 != collapse_special(content)) {
+		    sax_drive_error(dr, "invalid format, special character does not end with a semicolon", 0);
+		}
+	    }
+	    args[0] = rb_str_new2(content);
+#if HAS_ENCODING_SUPPORT
+	    if (0 != dr->encoding) {
+		rb_enc_associate(args[0], dr->encoding);
+	    }
+#endif
+	    rb_funcall2(dr->handler, ox_text_id, 1, args);
+	}
+	dr->cur = cend;
+    } else {
+	c = next_non_white(dr);
+	if ('>' != c) {
+	    sax_drive_error(dr, "invalid format, instruction not terminated", 1);
+	    return -1;
+	}
     }
-    c = next_non_white(dr);
-    if ('>' != c) {
-        sax_drive_error(dr, "invalid format, instruction not terminated", 1);
-        return -1;
+    if (dr->has_end_instruct) {
+        VALUE       args[1];
+
+        args[0] = target;
+        rb_funcall2(dr->handler, ox_end_instruct_id, 1, args);
     }
     dr->str = 0;
 
@@ -649,6 +709,7 @@ read_comment(SaxDrive dr) {
 static int
 read_element(SaxDrive dr) {
     VALUE       name = Qnil;
+    const char	*err;
     char        c;
     int         closed;
 
@@ -667,7 +728,8 @@ read_element(SaxDrive dr) {
     } else if ('>' == c) {
         closed = 0;
     } else {
-        if (0 != read_attrs(dr, c, '/', '>', 0)) {
+        if (0 != (err = read_attrs(dr, c, '/', '>', 0))) {
+	    sax_drive_error(dr, err, 1);
             return -1;
         }
         closed = ('/' == *(dr->cur - 1));
@@ -739,10 +801,12 @@ read_text(SaxDrive dr) {
 #endif
         rb_funcall2(dr->handler, ox_text_id, 1, args);
     }
+    dr->str = 0;
+
     return 0;
 }
 
-static int
+static const char*
 read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
     VALUE       name = Qnil;
     int         is_encoding = 0;
@@ -754,11 +818,10 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
     while (termc != c && term2 != c) {
         dr->cur--;
         if ('\0' == c) {
-            sax_drive_error(dr, "invalid format, processing instruction not terminated", 1);
-            return -1;
+	    return "invalid format, attributes not terminated";
         }
         if ('\0' == (c = read_name_token(dr))) {
-            return -1;
+            return "error reading tolen";
         }
         if (is_xml && 0 == strcmp("encoding", dr->str)) {
             is_encoding = 1;
@@ -771,11 +834,10 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
             c = next_non_white(dr);
         }
         if ('=' != c) {
-            sax_drive_error(dr, "invalid format, no attribute value", 1);
-            return -1;
+            return "invalid format, no attribute value";
         }
         if (0 != read_quoted_value(dr)) {
-            return -1;
+            return "error reading quoted value";
         }
         if (is_encoding) {
 #if HAS_ENCODING_SUPPORT
@@ -806,6 +868,8 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
         }
         c = next_non_white(dr);
     }
+    dr->str = 0;
+
     return 0;
 }
 
@@ -870,6 +934,7 @@ read_quoted_value(SaxDrive dr) {
 	}
     }        
     *(dr->cur - 1) = '\0'; /* terminate value */
+
     return 0;
 }
 

data/lib/ox.rb

@@ -88,8 +88,10 @@ end
 
 require 'ox/version'
 require 'ox/invalidpath'
+require 'ox/hasattrs'
 require 'ox/node'
 require 'ox/comment'
+require 'ox/instruct'
 require 'ox/cdata'
 require 'ox/doctype'
 require 'ox/element'

data/lib/ox/element.rb

@@ -35,6 +35,7 @@ module Ox
   #   => "58"
 
   class Element < Node
+    include HasAttrs
     
     # Creates a new Element with the specified name.
     # @param [String] name name of the Element
@@ -61,29 +62,6 @@ module Ox
       @nodes << node
     end
 
-    # Returns all the attributes of the Element as a Hash.
-    # @return [Hash] all attributes and attribute values.
-    def attributes
-      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
-      @attributes
-    end
-    
-    # Returns the value of an attribute.
-    # @param [Symbol|String] attr attribute name or key to return the value for
-    def [](attr)
-      return nil unless instance_variable_defined?(:@attributes) and @attributes.is_a?(Hash)
-      @attributes[attr] or (attr.is_a?(String) ? @attributes[attr.to_sym] : @attributes[attr.to_s])
-    end
-
-    # Adds or set an attribute of the Element.
-    # @param [Symbol|String] attr attribute name or key
-    # @param [Object] value value for the attribute
-    def []=(attr, value)
-      raise "argument to [] must be a Symbol or a String." unless attr.is_a?(Symbol) or attr.is_a?(String)
-      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
-      @attributes[attr] = value.to_s
-    end
-
     # Returns true if this Object and other are of the same type and have the
     # equivalent value and the equivalent elements otherwise false is returned.
     # @param [Object] other Object compare _self_ to.
@@ -156,7 +134,7 @@ module Ox
       ids = id.to_s
       i = args[0].to_i # will be 0 if no arg or parsing fails
       @nodes.each do |n|
-        if n.is_a?(Element) && (n.value == id || n.value == ids)
+        if (n.is_a?(Element) || n.is_a?(Instruct)) && (n.value == id || n.value == ids)
           return n if 0 == i
           i -= 1
         end
@@ -165,7 +143,7 @@ module Ox
         return @attributes[id] if @attributes.has_key?(id)
         return @attributes[ids] if @attributes.has_key?(ids)
       end
-      raise NoMethodError.new("#{name} not found", name)
+      raise NoMethodError.new("#{ids} not found", name)
     end
 
     # @param [Array] path array of steps in a path

data/lib/ox/hasattrs.rb

@@ -0,0 +1,49 @@
+
+module Ox
+
+  # An Object that includes the HasAttrs module can have attributes which are a Hash of String values and either String
+  # or Symbol keys.
+  #
+  # To access the attributes there are several options. One is to walk the attributes. The easiest for simple regularly
+  # formatted XML is to reference the attributes simply by name.
+
+  module HasAttrs
+    # Returns all the attributes of the Instruct as a Hash.
+    # @return [Hash] all attributes and attribute values.
+    def attributes
+      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
+      @attributes
+    end
+    
+    # Returns the value of an attribute.
+    # @param [Symbol|String] attr attribute name or key to return the value for
+    def [](attr)
+      return nil unless instance_variable_defined?(:@attributes) and @attributes.is_a?(Hash)
+      @attributes[attr] or (attr.is_a?(String) ? @attributes[attr.to_sym] : @attributes[attr.to_s])
+    end
+
+    # Adds or set an attribute of the Instruct.
+    # @param [Symbol|String] attr attribute name or key
+    # @param [Object] value value for the attribute
+    def []=(attr, value)
+      raise "argument to [] must be a Symbol or a String." unless attr.is_a?(Symbol) or attr.is_a?(String)
+      @attributes = { } if !instance_variable_defined?(:@attributes) or @attributes.nil?
+      @attributes[attr] = value.to_s
+    end
+    
+    # Handles the 'easy' API that allows navigating a simple XML by
+    # referencing attributes by name.
+    # @param [Symbol] id element or attribute name
+    # @return [String|nil] the attribute value
+    # @raise [NoMethodError] if no match is found
+    def method_missing(id, *args, &block)
+      ids = id.to_s
+      if instance_variable_defined?(:@attributes)
+        return @attributes[id] if @attributes.has_key?(id)
+        return @attributes[ids] if @attributes.has_key?(ids)
+      end
+      raise NoMethodError.new("#{ids} not found", name)
+    end
+
+  end # HasAttrs
+end # Ox

data/lib/ox/instruct.rb

@@ -0,0 +1,38 @@
+
+module Ox
+
+  # An Instruct represents a processing instruction of an XML document. It has a target, attributes, and a value or
+  # content. The content will be all characters with the exception of the target. If the content follows a regular
+  # attribute format then the attributes will be set to the parsed values. If it does not follow the attribute formate
+  # then the attributes will be empty.
+
+  class Instruct < Node
+    include HasAttrs
+
+    # The content of the processing instruction.
+    attr_accessor :content
+
+    # Creates a new Instruct with the specified name.
+    # @param [String] name name of the Instruct
+    def initialize(name)
+      super
+      @attributes = nil
+      @content = nil
+    end
+    alias target value
+    
+    # Returns true if this Object and other are of the same type and have the
+    # equivalent value and the equivalent elements otherwise false is returned.
+    # @param [Object] other Object compare _self_ to.
+    # @return [Boolean] true if both Objects are equivalent, otherwise false.
+    def eql?(other)
+      return false if (other.nil? or self.class != other.class)
+      return false unless super(other)
+      return false unless self.attributes == other.attributes
+      return false unless self.content == other.content
+      true
+    end
+    alias == eql?
+    
+  end # Instruct
+end # Ox

data/lib/ox/sax.rb

@@ -32,6 +32,7 @@ module Ox
   # public. The same is true for attr() and attr_value().
   #
   #    def instruct(target); end
+  #    def end_instruct(target); end
   #    def attr(name, str); end
   #    def attr_value(name, value); end
   #    def doctype(str); end
@@ -55,6 +56,9 @@ module Ox
     def instruct(target)
     end
 
+    def end_instruct(target)
+    end
+
     def attr(name, str)
     end
 

data/lib/ox/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-06 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies: []
 description: ! "A fast XML parser and object serializer that uses only standard C
   lib.\n            \nOptimized XML (Ox), as the name implies was written to provide
@@ -29,6 +29,8 @@ files:
 - lib/ox/doctype.rb
 - lib/ox/document.rb
 - lib/ox/element.rb
+- lib/ox/hasattrs.rb
+- lib/ox/instruct.rb
 - lib/ox/invalidpath.rb
 - lib/ox/node.rb
 - lib/ox/sax.rb