ox 1.5.4 → 1.5.5

data/ext/ox/ox.c

@@ -49,7 +49,9 @@ void Init_ox();
 VALUE    Ox = Qnil;
 
 ID	ox_at_id;
+ID	ox_at_value_id;
 ID	ox_attr_id;
+ID	ox_attr_value_id;
 ID	ox_attributes_id;
 ID	ox_beg_id;
 ID	ox_cdata_id;
@@ -74,11 +76,13 @@ ID	ox_parse_id;
 ID	ox_read_id;
 ID	ox_readpartial_id;
 ID	ox_start_element_id;
+ID	ox_string_id;
 ID	ox_text_id;
 ID	ox_to_c_id;
 ID	ox_to_s_id;
 ID	ox_to_sym_id;
 ID	ox_tv_sec_id;
+ID	ox_tv_nsec_id;
 ID	ox_tv_usec_id;
 ID	ox_value_id;
 
@@ -96,6 +100,7 @@ VALUE   ox_bag_clas;
 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;
@@ -476,7 +481,7 @@ 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", len, path);
+        rb_raise(rb_eLoadError, "Failed to read %ld bytes from %s.\n", (long)len, path);
     }
     fclose(f);
     xml[len] = '\0';
@@ -601,7 +606,7 @@ dump(int argc, VALUE *argv, VALUE self) {
         rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(xml);
-#ifdef ENCODING_INLINE_MAX
+#if HAS_ENCODING_SUPPORT
     if ('\0' != *copts.encoding) {
         rb_enc_associate(rstr, rb_enc_find(copts.encoding));
     }
@@ -654,10 +659,7 @@ cache8_test(VALUE self) {
 }
 
 void Init_ox() {
-    VALUE       keep = Qnil;
-
     Ox = rb_define_module("Ox");
-    keep = rb_cv_get(Ox, "@@keep"); // needed to stop GC from deleting and reusing VALUEs
 
     rb_define_module_function(Ox, "default_options", get_def_opts, 0);
     rb_define_module_function(Ox, "default_options=", set_def_opts, 1);
@@ -674,9 +676,13 @@ void Init_ox() {
     rb_define_module_function(Ox, "to_file", to_file, -1);
 
     rb_require("time");
+    rb_require("date");
+    rb_require("stringio");
 
     ox_at_id = rb_intern("at");
+    ox_at_value_id = rb_intern("@value");
     ox_attr_id = rb_intern("attr");
+    ox_attr_value_id = rb_intern("attr_value");
     ox_attributes_id = rb_intern("@attributes");
     ox_beg_id = rb_intern("@beg");
     ox_cdata_id = rb_intern("cdata");
@@ -701,43 +707,45 @@ void Init_ox() {
     ox_readpartial_id = rb_intern("readpartial");
     ox_read_id = rb_intern("read");
     ox_start_element_id = rb_intern("start_element");
+    ox_string_id = rb_intern("string");
     ox_text_id = rb_intern("text");
+    ox_value_id = rb_intern("value");
     ox_to_c_id = rb_intern("to_c");
     ox_to_s_id = rb_intern("to_s");
     ox_to_sym_id = rb_intern("to_sym");
     ox_tv_sec_id = rb_intern("tv_sec");
+    ox_tv_nsec_id = rb_intern("tv_nsec");
     ox_tv_usec_id = rb_intern("tv_usec");
-    ox_value_id = rb_intern("@value");
 
     ox_time_class = rb_const_get(rb_cObject, rb_intern("Time"));
     ox_date_class = rb_const_get(rb_cObject, rb_intern("Date"));
     ox_struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
+    ox_stringio_class = rb_const_get(rb_cObject, rb_intern("StringIO"));
+
+    ox_encoding_sym = ID2SYM(rb_intern("encoding"));		rb_gc_register_address(&ox_encoding_sym);
+    indent_sym = ID2SYM(rb_intern("indent"));                   rb_gc_register_address(&indent_sym);
+    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));               rb_gc_register_address(&xsd_date_sym);
+    opt_format_sym = ID2SYM(rb_intern("opt_format"));           rb_gc_register_address(&opt_format_sym);
+    mode_sym = ID2SYM(rb_intern("mode"));                       rb_gc_register_address(&mode_sym);
+    auto_sym = ID2SYM(rb_intern("auto"));                       rb_gc_register_address(&auto_sym);
+    optimized_sym = ID2SYM(rb_intern("optimized"));             rb_gc_register_address(&optimized_sym);
+    object_sym = ID2SYM(rb_intern("object"));                   rb_gc_register_address(&object_sym);
+    circular_sym = ID2SYM(rb_intern("circular"));               rb_gc_register_address(&circular_sym);
+    generic_sym = ID2SYM(rb_intern("generic"));                 rb_gc_register_address(&generic_sym);
+    limited_sym = ID2SYM(rb_intern("limited"));                 rb_gc_register_address(&limited_sym);
+    trace_sym = ID2SYM(rb_intern("trace"));                     rb_gc_register_address(&trace_sym);
+    effort_sym = ID2SYM(rb_intern("effort"));                   rb_gc_register_address(&effort_sym);
+    strict_sym = ID2SYM(rb_intern("strict"));                   rb_gc_register_address(&strict_sym);
+    tolerant_sym = ID2SYM(rb_intern("tolerant"));               rb_gc_register_address(&tolerant_sym);
+    auto_define_sym = ID2SYM(rb_intern("auto_define"));         rb_gc_register_address(&auto_define_sym);
+    with_dtd_sym = ID2SYM(rb_intern("with_dtd"));               rb_gc_register_address(&with_dtd_sym);
+    with_instruct_sym = ID2SYM(rb_intern("with_instructions")); rb_gc_register_address(&with_instruct_sym);
+    with_xml_sym = ID2SYM(rb_intern("with_xml"));               rb_gc_register_address(&with_xml_sym);
+    convert_special_sym = ID2SYM(rb_intern("convert_special")); rb_gc_register_address(&convert_special_sym);
+
+    ox_empty_string = rb_str_new2("");				rb_gc_register_address(&ox_empty_string);
+    ox_zero_fixnum = INT2NUM(0);				rb_gc_register_address(&ox_zero_fixnum);
 
-    ox_encoding_sym = ID2SYM(rb_intern("encoding"));		rb_ary_push(keep, ox_encoding_sym);
-    indent_sym = ID2SYM(rb_intern("indent"));                   rb_ary_push(keep, indent_sym);
-    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));               rb_ary_push(keep, xsd_date_sym);
-    opt_format_sym = ID2SYM(rb_intern("opt_format"));           rb_ary_push(keep, opt_format_sym);
-    mode_sym = ID2SYM(rb_intern("mode"));                       rb_ary_push(keep, mode_sym);
-    auto_sym = ID2SYM(rb_intern("auto"));                       rb_ary_push(keep, auto_sym);
-    optimized_sym = ID2SYM(rb_intern("optimized"));             rb_ary_push(keep, optimized_sym);
-    object_sym = ID2SYM(rb_intern("object"));                   rb_ary_push(keep, object_sym);
-    circular_sym = ID2SYM(rb_intern("circular"));               rb_ary_push(keep, circular_sym);
-    generic_sym = ID2SYM(rb_intern("generic"));                 rb_ary_push(keep, generic_sym);
-    limited_sym = ID2SYM(rb_intern("limited"));                 rb_ary_push(keep, limited_sym);
-    trace_sym = ID2SYM(rb_intern("trace"));                     rb_ary_push(keep, trace_sym);
-    effort_sym = ID2SYM(rb_intern("effort"));                   rb_ary_push(keep, effort_sym);
-    strict_sym = ID2SYM(rb_intern("strict"));                   rb_ary_push(keep, strict_sym);
-    tolerant_sym = ID2SYM(rb_intern("tolerant"));               rb_ary_push(keep, tolerant_sym);
-    auto_define_sym = ID2SYM(rb_intern("auto_define"));         rb_ary_push(keep, auto_define_sym);
-    with_dtd_sym = ID2SYM(rb_intern("with_dtd"));               rb_ary_push(keep, with_dtd_sym);
-    with_instruct_sym = ID2SYM(rb_intern("with_instructions")); rb_ary_push(keep, with_instruct_sym);
-    with_xml_sym = ID2SYM(rb_intern("with_xml"));               rb_ary_push(keep, with_xml_sym);
-    convert_special_sym = ID2SYM(rb_intern("convert_special")); rb_ary_push(keep, convert_special_sym);
-
-    ox_empty_string = rb_str_new2("");				rb_ary_push(keep, ox_empty_string);
-    ox_zero_fixnum = INT2NUM(0);				rb_ary_push(keep, ox_zero_fixnum);
-
-    //rb_require("node"); // generic xml node classes
     ox_document_clas = rb_const_get_at(Ox, rb_intern("Document"));
     ox_element_clas = rb_const_get_at(Ox, rb_intern("Element"));
     ox_comment_clas = rb_const_get_at(Ox, rb_intern("Comment"));
@@ -749,6 +757,8 @@ void Init_ox() {
     ox_cache_new(&ox_class_cache);
     ox_cache_new(&ox_attr_cache);
 
+    ox_sax_define();
+
     rb_define_module_function(Ox, "cache_test", cache_test, 0);
     rb_define_module_function(Ox, "cache8_test", cache8_test, 0);
 }

data/ext/ox/ox.h

@@ -38,26 +38,26 @@ extern "C" {
 #endif
 #endif
 
+#define RSTRING_NOT_MODIFIED
+
 #include "ruby.h"
-#ifdef HAVE_RUBY_ENCODING_H
-// HAVE_RUBY_ENCODING_H defined for Ruby 1.9
+#if HAS_ENCODING_SUPPORT
 #include "ruby/encoding.h"
 #endif
-#include "cache.h"
 
-#ifdef JRUBY
-#define NO_RSTRUCT 1
+#ifdef RUBINIUS_RUBY
+#undef T_COMPLEX
+enum st_retval {ST_CONTINUE = 0, ST_STOP = 1, ST_DELETE = 2, ST_CHECK};
+#else
+#if HAS_TOP_LEVEL_ST_H
+// Only on travis, local is where it is for all others. Seems to vary depending on the travis machine picked up.
+#include "st.h"
+#else
+#include "ruby/st.h"
 #endif
-
-#if (defined RBX_Qnil && !defined RUBINIUS)
-#define RUBINIUS
 #endif
 
-#ifdef RUBINIUS
-#undef T_RATIONAL
-#undef T_COMPLEX
-#define NO_RSTRUCT 1
-#endif
+#include "cache.h"
 
 #define raise_error(msg, xml, current) _ox_raise_error(msg, xml, current, __FILE__, __LINE__)
 
@@ -210,6 +210,8 @@ extern VALUE	ox_parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Eff
 extern void	_ox_raise_error(const char *msg, const char *xml, const char *current, const char* file, int line);
 
 extern void	ox_sax_parse(VALUE handler, VALUE io, int convert);
+extern void	ox_sax_define(void);
+
 
 extern char*	ox_write_obj_to_str(VALUE obj, Options copts);
 extern void	ox_write_obj_to_file(VALUE obj, const char *path, Options copts);
@@ -219,7 +221,9 @@ extern struct _Options  ox_default_options;
 extern VALUE    Ox;
 
 extern ID	ox_at_id;
+extern ID	ox_at_value_id;
 extern ID	ox_attr_id;
+extern ID	ox_attr_value_id;
 extern ID	ox_attributes_id;
 extern ID	ox_beg_id;
 extern ID	ox_cdata_id;
@@ -244,11 +248,13 @@ extern ID	ox_parse_id;
 extern ID	ox_read_id;
 extern ID	ox_readpartial_id;
 extern ID	ox_start_element_id;
+extern ID	ox_string_id;
 extern ID	ox_text_id;
 extern ID	ox_to_c_id;
 extern ID	ox_to_s_id;
 extern ID	ox_to_sym_id;
 extern ID	ox_tv_sec_id;
+extern ID	ox_tv_nsec_id;
 extern ID	ox_tv_usec_id;
 extern ID	ox_value_id;
 
@@ -257,6 +263,7 @@ extern VALUE    ox_empty_string;
 extern VALUE    ox_encoding_sym;
 extern VALUE    ox_struct_class;
 extern VALUE    ox_time_class;
+extern VALUE	ox_stringio_class;
 extern VALUE    ox_zero_fixnum;
 
 extern VALUE    ox_document_clas;

data/ext/ox/parse.c

@@ -200,6 +200,7 @@ read_instruction(PInfo pi) {
 	    if (MAX_ATTRS <= (a - attrs)) {
 		raise_error("too many attributes", pi->str, pi->s);
 	    }
+	    next_non_white(pi);
 	}
 	if ('?' == *pi->s) {
 	    pi->s++;

data/ext/ox/sax.c

@@ -31,10 +31,11 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <stdio.h>
-#include <string.h>
+#include <strings.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
+#include <time.h>
 
 #include "ruby.h"
 #include "ox.h"
@@ -50,22 +51,26 @@ typedef struct _SaxDrive {
     int         line;
     int         col;
     VALUE       handler;
+    VALUE	value_obj;
     int         (*read_func)(struct _SaxDrive *dr);
     int         convert_special;
     union {
-        int     fd;
-        VALUE   io;
+        int     	fd;
+        VALUE   	io;
+	const char	*in_str;
     };
     int         has_instruct;
     int         has_attr;
+    int         has_attr_value;
     int         has_doctype;
     int         has_comment;
     int         has_cdata;
     int         has_text;
+    int         has_value;
     int         has_start_element;
     int         has_end_element;
     int         has_error;
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
     rb_encoding *encoding;
 #endif
 } *SaxDrive;
@@ -91,8 +96,14 @@ 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);
+#endif
 static int      read_from_io_partial(SaxDrive dr);
+static int      read_from_str(SaxDrive dr);
+
+static VALUE	sax_value_class;
+
 
 static inline char
 sax_drive_get(SaxDrive dr) {
@@ -176,7 +187,7 @@ str2sym(const char *str, SaxDrive dr) {
     VALUE       sym;
 
     if (Qundef == (sym = ox_cache_get(ox_symbol_cache, str, &slot))) {
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
         if (0 != dr->encoding) {
 	    VALUE	rstr = rb_str_new2(str);
 
@@ -203,10 +214,12 @@ ox_sax_parse(VALUE handler, VALUE io, int convert) {
     printf("*** sax_parse with these flags\n");
     printf("    has_instruct = %s\n", dr.has_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");
     printf("    has_comment = %s\n", dr.has_comment ? "true" : "false");
     printf("    has_cdata = %s\n", dr.has_cdata ? "true" : "false");
     printf("    has_text = %s\n", dr.has_text ? "true" : "false");
+    printf("    has_value = %s\n", dr.has_value ? "true" : "false");
     printf("    has_start_element = %s\n", dr.has_start_element ? "true" : "false");
     printf("    has_end_element = %s\n", dr.has_end_element ? "true" : "false");
     printf("    has_error = %s\n", dr.has_error ? "true" : "false");
@@ -215,9 +228,34 @@ ox_sax_parse(VALUE handler, VALUE io, int convert) {
     sax_drive_cleanup(&dr);
 }
 
+inline static int
+respond_to(VALUE obj, ID method) {
+#ifdef JRUBY_RUBY
+    // There is a bug in JRuby where rb_respond_to() returns true (1) even if
+    // a method is private.
+    {
+	VALUE	args[1];
+
+	*args = ID2SYM(method);
+	return (Qtrue == rb_funcall2(obj, rb_intern("respond_to?"), 1, args));
+    }
+#else
+    return rb_respond_to(obj, method);
+#endif
+}
+
 static void
 sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
-    if (rb_respond_to(io, ox_readpartial_id)) {
+    if (ox_stringio_class == rb_obj_class(io)) {
+	VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
+
+	dr->read_func = read_from_str;
+	dr->in_str = StringValuePtr(s);
+    } else if (rb_respond_to(io, ox_readpartial_id)) {
+#ifdef JRUBY_RUBY
+	dr->read_func = read_from_io_partial;
+	dr->io = io;
+#else
         VALUE   rfd;
 
         if (rb_respond_to(io, ox_fileno_id) && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
@@ -227,7 +265,12 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
             dr->read_func = read_from_io_partial;
             dr->io = io;
         }
+#endif
     } else if (rb_respond_to(io, ox_read_id)) {
+#ifdef JRUBY_RUBY
+	dr->read_func = read_from_io;
+	dr->io = io;
+#else
         VALUE   rfd;
 
         if (rb_respond_to(io, ox_fileno_id) && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
@@ -237,6 +280,7 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
             dr->read_func = read_from_io;
             dr->io = io;
         }
+#endif
     } else {
         rb_raise(rb_eArgError, "sax_parser io argument must respond to readpartial() or read().\n");
     }
@@ -249,17 +293,21 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
     dr->line = 1;
     dr->col = 0;
     dr->handler = handler;
+    dr->value_obj = rb_data_object_alloc(sax_value_class, dr, 0, 0);
+    rb_gc_register_address(&dr->value_obj);
     dr->convert_special = convert;
-    dr->has_instruct = rb_respond_to(handler, ox_instruct_id);
-    dr->has_attr = rb_respond_to(handler, ox_attr_id);
-    dr->has_doctype = rb_respond_to(handler, ox_doctype_id);
-    dr->has_comment = rb_respond_to(handler, ox_comment_id);
-    dr->has_cdata = rb_respond_to(handler, ox_cdata_id);
-    dr->has_text = rb_respond_to(handler, ox_text_id);
-    dr->has_start_element = rb_respond_to(handler, ox_start_element_id);
-    dr->has_end_element = rb_respond_to(handler, ox_end_element_id);
-    dr->has_error = rb_respond_to(handler, ox_error_id);
-#ifdef HAVE_RUBY_ENCODING_H
+    dr->has_instruct = respond_to(handler, ox_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);
+    dr->has_comment = respond_to(handler, ox_comment_id);
+    dr->has_cdata = respond_to(handler, ox_cdata_id);
+    dr->has_text = respond_to(handler, ox_text_id);
+    dr->has_value = respond_to(handler, ox_value_id);
+    dr->has_start_element = respond_to(handler, ox_start_element_id);
+    dr->has_end_element = respond_to(handler, ox_end_element_id);
+    dr->has_error = respond_to(handler, ox_error_id);
+#if HAS_ENCODING_SUPPORT
     if ('\0' == *ox_default_options.encoding) {
         dr->encoding = 0;
     } else {
@@ -270,6 +318,7 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
 
 static void
 sax_drive_cleanup(SaxDrive dr) {
+    rb_gc_unregister_address(&dr->value_obj);
     if (dr->base_buf != dr->buf) {
         xfree(dr->buf);
     }
@@ -505,7 +554,7 @@ read_cdata(SaxDrive dr) {
         VALUE       args[1];
 
         args[0] = rb_str_new2(dr->str);
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
@@ -549,7 +598,7 @@ read_comment(SaxDrive dr) {
         VALUE       args[1];
 
         args[0] = rb_str_new2(dr->str);
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
@@ -573,7 +622,6 @@ read_element(SaxDrive dr) {
     if ('\0' == (c = read_name_token(dr))) {
         return -1;
     }
-    // TBD encode is needed
     name = str2sym(dr->str, dr);
     if (dr->has_start_element) {
         VALUE       args[1];
@@ -637,16 +685,21 @@ read_text(SaxDrive dr) {
         }
     }
     *(dr->cur - 1) = '\0';
-    if (dr->has_text) {
+    if (dr->has_value) {
         VALUE   args[1];
-        
+
+	*args = dr->value_obj;
+        rb_funcall2(dr->handler, ox_value_id, 1, args);
+    } else if (dr->has_text) {
+        VALUE   args[1];
+
         if (dr->convert_special) {
             if (0 != collapse_special(dr->str) && 0 != strchr(dr->str, '&')) {
                 sax_drive_error(dr, "invalid format, special character does not end with a semicolon", 0);
             }
         }
         args[0] = rb_str_new2(dr->str);
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
@@ -677,7 +730,8 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
         if (is_xml && 0 == strcmp("encoding", dr->str)) {
             is_encoding = 1;
         }
-        if (dr->has_attr) {
+	// TBD use symbol cache
+        if (dr->has_attr || dr->has_attr_value) {
             name = str2sym(dr->str, dr);
         }
         if (is_white(c)) {
@@ -690,12 +744,18 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
         if (0 != read_quoted_value(dr)) {
             return -1;
         }
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
         if (is_encoding) {
             dr->encoding = rb_enc_find(dr->str);
         }
 #endif
-        if (dr->has_attr) {
+        if (dr->has_attr_value) {
+            VALUE       args[2];
+
+            args[0] = name;
+            args[1] = dr->value_obj;
+            rb_funcall2(dr->handler, ox_attr_value_id, 2, args);
+	} else if (dr->has_attr) {
             VALUE       args[2];
 
             args[0] = name;
@@ -703,7 +763,7 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
                 sax_drive_error(dr, "invalid format, special character does not end with a semicolon", 0);
             }
             args[1] = rb_str_new2(dr->str);
-#ifdef HAVE_RUBY_ENCODING_H
+#if HAS_ENCODING_SUPPORT
             if (0 != dr->encoding) {
                 rb_enc_associate(args[1], dr->encoding);
             }
@@ -781,12 +841,21 @@ read_quoted_value(SaxDrive dr) {
 
 static VALUE
 rescue_cb(VALUE rdr, VALUE err) {
+#ifndef JRUBY_RUBY
+    // JRuby seems to play by a different set if rules. It passes in an Fixnum
+    // instead of an error like other Rubies. For now assume all errors are
+    // EOF and deal with the results further down the line.
+#if (defined(RUBINIUS_RUBY) || (1 == RUBY_VERSION_MAJOR && 8 == RUBY_VERSION_MINOR))
+    if (rb_obj_class(err) != rb_eTypeError) {
+#else
     if (rb_obj_class(err) != rb_eEOFError) {
+#endif
 	SaxDrive	dr = (SaxDrive)rdr;
 
         sax_drive_cleanup(dr);
         rb_raise(err, "at line %d, column %d\n", dr->line, dr->col);
     }
+#endif
     return Qfalse;
 }
 
@@ -839,6 +908,7 @@ read_from_io(SaxDrive dr) {
     return (Qfalse == rb_rescue(io_cb, (VALUE)dr, rescue_cb, (VALUE)dr));
 }
 
+#ifndef JRUBY_RUBY
 static int
 read_from_fd(SaxDrive dr) {
     ssize_t     cnt;
@@ -853,7 +923,26 @@ read_from_fd(SaxDrive dr) {
     }
     return 0;
 }
+#endif
+
+static int
+read_from_str(SaxDrive dr) {
+    size_t      max = dr->buf_end - dr->cur - 1;
+    char	*s;
+    long	cnt;
+
+    if ('\0' == *dr->in_str) {
+	// done
+	return -1;
+    }
+    s = stpncpy(dr->cur, dr->in_str, max);
+    *s = '\0';
+    cnt = s - dr->cur;
+    dr->in_str += cnt;
+    dr->read_end = dr->cur + cnt;
 
+    return 0;
+}
 
 static int
 collapse_special(char *str) {
@@ -911,3 +1000,211 @@ collapse_special(char *str) {
 
     return 0;
 }
+
+static VALUE
+parse_double_time(const char *text) {
+    long        v = 0;
+    long        v2 = 0;
+    const char  *dot = 0;
+    char        c;
+    
+    for (; '.' != *text; text++) {
+        c = *text;
+        if (c < '0' || '9' < c) {
+            return Qnil;
+        }
+        v = 10 * v + (long)(c - '0');
+    }
+    dot = text++;
+    for (; '\0' != *text && text - dot <= 6; text++) {
+        c = *text;
+        if (c < '0' || '9' < c) {
+            return Qnil;
+        }
+        v2 = 10 * v2 + (long)(c - '0');
+    }
+    for (; text - dot <= 9; text++) {
+        v2 *= 10;
+    }
+#if HAS_NANO_TIME
+    return rb_time_nano_new(v, v2);
+#else
+    return rb_time_new(v, v2 / 1000);
+#endif
+}
+
+typedef struct _Tp {
+    int         cnt;
+    char        end;
+    char        alt;
+} *Tp;
+
+static VALUE
+parse_xsd_time(const char *text) {
+    long        cargs[10];
+    long        *cp = cargs;
+    long        v;
+    int         i;
+    char        c = '\0';
+    struct _Tp  tpa[10] = { { 4, '-', '-' },
+                           { 2, '-', '-' },
+                           { 2, 'T', ' ' },
+                           { 2, ':', ':' },
+                           { 2, ':', ':' },
+                           { 2, '.', '.' },
+                           { 9, '+', '-' },
+                           { 2, ':', ':' },
+                           { 2, '\0', '\0' },
+                           { 0, '\0', '\0' } };
+    Tp          tp = tpa;
+    struct tm   tm;
+
+    memset(cargs, 0, sizeof(cargs));
+    for (; 0 != tp->cnt; tp++) {
+        for (i = tp->cnt, v = 0; 0 < i ; text++, i--) {
+            c = *text;
+            if (c < '0' || '9' < c) {
+                if ('\0' == c || tp->end == c || tp->alt == c) {
+                    break;
+                }
+		return Qnil;
+            }
+            v = 10 * v + (long)(c - '0');
+        }
+	if ('\0' == c) {
+	    break;
+	}
+        c = *text++;
+        if (tp->end != c && tp->alt != c) {
+	    return Qnil;
+        }
+        *cp++ = v;
+    }
+    tm.tm_year = (int)cargs[0] - 1900;
+    tm.tm_mon = (int)cargs[1] - 1;
+    tm.tm_mday = (int)cargs[2];
+    tm.tm_hour = (int)cargs[3];
+    tm.tm_min = (int)cargs[4];
+    tm.tm_sec = (int)cargs[5];
+#if HAS_NANO_TIME
+    return rb_time_nano_new(mktime(&tm), cargs[6]);
+#else
+    return rb_time_new(mktime(&tm), cargs[6] / 1000);
+#endif
+}
+
+static VALUE
+sax_value_as_s(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    VALUE	rs;
+
+    if ('\0' == *dr->str) {
+	return Qnil;
+    }
+    if (dr->convert_special) {
+	if (0 != collapse_special(dr->str) && 0 != strchr(dr->str, '&')) {
+	    sax_drive_error(dr, "invalid format, special character does not end with a semicolon", 0);
+	}
+    }
+    rs = rb_str_new2(dr->str);
+#if HAS_ENCODING_SUPPORT
+    if (0 != dr->encoding) {
+	rb_enc_associate(rs, dr->encoding);
+    }
+#endif
+    return rs;
+}
+
+static VALUE
+sax_value_as_sym(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+
+    if ('\0' == *dr->str) {
+	return Qnil;
+    }
+    return str2sym(dr->str, dr);
+}
+
+static VALUE
+sax_value_as_f(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+
+    if ('\0' == *dr->str) {
+	return Qnil;
+    }
+    return rb_float_new(strtod(dr->str, 0));
+}
+
+static VALUE
+sax_value_as_i(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    const char	*s = dr->str;
+    long	n = 0;
+    int		neg = 0;
+
+    if ('\0' == *s) {
+	return Qnil;
+    }
+    if ('-' == *s) {
+	neg = 1;
+	s++;
+    } else if ('+' == *s) {
+	s++;
+    }
+    for (; '\0' != *s; s++) {
+	if ('0' <= *s && *s <= '9') {
+	    n = n * 10 + (*s - '0');
+	} else {
+	    rb_raise(rb_eArgError, "Not a valid Fixnum.\n");
+	}
+    }
+    if (neg) {
+	n = -n;
+    }
+    return LONG2NUM(n);
+}
+
+static VALUE
+sax_value_as_time(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    const char	*str = dr->str;
+    VALUE       t;
+
+    if ('\0' == *str) {
+	return Qnil;
+    }
+    if (Qnil == (t = parse_double_time(str)) &&
+	Qnil == (t = parse_xsd_time(str))) {
+        VALUE       args[1];
+
+        //printf("**** time parse\n");
+        *args = rb_str_new2(str);
+        t = rb_funcall2(ox_time_class, ox_parse_id, 1, args);
+    }
+    return t;
+}
+
+static VALUE
+sax_value_as_bool(VALUE self) {
+    return (0 == strcasecmp("true", ((SaxDrive)DATA_PTR(self))->str)) ? Qtrue : Qfalse;
+}
+
+static VALUE
+sax_value_empty(VALUE self) {
+    return ('\0' == *((SaxDrive)DATA_PTR(self))->str) ? Qtrue : Qfalse;
+}
+
+void
+ox_sax_define() {
+    VALUE	sax_module = rb_const_get_at(Ox, rb_intern("Sax"));
+
+    sax_value_class = rb_define_class_under(sax_module, "Value", rb_cObject);
+
+    rb_define_method(sax_value_class, "as_s", sax_value_as_s, 0);
+    rb_define_method(sax_value_class, "as_sym", sax_value_as_sym, 0);
+    rb_define_method(sax_value_class, "as_i", sax_value_as_i, 0);
+    rb_define_method(sax_value_class, "as_f", sax_value_as_f, 0);
+    rb_define_method(sax_value_class, "as_time", sax_value_as_time, 0);
+    rb_define_method(sax_value_class, "as_bool", sax_value_as_bool, 0);
+    rb_define_method(sax_value_class, "empty?", sax_value_empty, 0);
+}