ox 1.8.4 → 1.8.5

data/README.md

@@ -34,13 +34,9 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.8.4
+### Release 1.8.5
 
- - Applied patch by mcarpenter to fix solaris issues with build and remaining undefined @nodes.
-
-### Release 1.8.3
-
- - Sax parser now honors encoding specification in the xml prolog correctly.
+ - added encoding support for JRuby where possible when in 1.9 mode.
 
 ## <a name="description">Description</a>
 

data/ext/ox/cache8.c

@@ -94,7 +94,7 @@ slot_print(Cache8 c, sid_t key, unsigned int depth) {
 	    k = (k8 << BITS) | i;
 	    /*printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i); */
 	    if (DEPTH - 1 == depth) {
-		printf("0x%016llx: %4llu\n", k, b->value);
+		printf("0x%016llx: %4llu\n", (unsigned long long)k, (unsigned long long)b->value);
 	    } else {
 		slot_print(b->child, k, depth + 1);
 	    }

data/ext/ox/cache8_test.c

@@ -55,13 +55,13 @@ ox_cache8_test() {
         v = ox_cache8_get(c, *d, &slot);
         if (0 == v) {
             if (0 == slot) {
-                printf("*** failed to get a slot for 0x%016llx\n", *d);
+                printf("*** failed to get a slot for 0x%016llx\n", (unsigned long long)*d);
             } else {
-                printf("*** adding 0x%016llx to cache with value %llu\n", *d, cnt);
+                printf("*** adding 0x%016llx to cache with value %llu\n", (unsigned long long)*d, (unsigned long long)cnt);
                 *slot = cnt++;
             }
         } else {
-            printf("*** get on 0x%016llx returned %llu\n", *d, v);
+            printf("*** get on 0x%016llx returned %llu\n", (unsigned long long)*d, (unsigned long long)v);
         }
         /*ox_cache8_print(c); */
     }

data/ext/ox/dump.c

@@ -1135,10 +1135,16 @@ dump_gen_nodes(VALUE obj, unsigned int depth, Out out) {
 
 static int
 dump_gen_attr(VALUE key, VALUE value, Out out) {
+#if HAS_PRIVATE_ENCODING
+    // There seems to be a bug in jruby for converting symbols to strings and preserving the encoding. This is a work
+    // around.
+    const char	*ks = rb_str_ptr(rb_String(key));
+#else
     const char  *ks = (T_SYMBOL == rb_type(key)) ? rb_id2name(SYM2ID(key)) : StringValuePtr(key);
+#endif
     size_t      klen = strlen(ks);
     size_t      size = 4 + klen + RSTRING_LEN(value);
-    
+
     if (out->end - out->cur <= (long)size) {
         grow(out, size);
     }

data/ext/ox/extconf.rb

@@ -23,6 +23,7 @@ dflags = {
                       !(platform.include?('solaris') || platform.include?('linux') || RUBY_PLATFORM =~ /(win|w)32$/)) ? 1 : 0,
   'HAS_ENCODING_SUPPORT' => (('ruby' == type || 'rubinius' == type) &&
                              (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
+  'HAS_PRIVATE_ENCODING' => ('jruby' == type && '1' == version[0] && '9' == version[1]) ? 1 : 0,
   'HAS_NANO_TIME' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,
   'HAS_RSTRUCT' => ('ruby' == type || 'ree' == type) ? 1 : 0,
   'HAS_IVAR_HELPERS' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,

data/ext/ox/gen_load.c

@@ -125,6 +125,15 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	    } else {
 		sym = ID2SYM(rb_intern(attrs->name));
 	    }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != pi->options->rb_enc) {
+		VALUE	rstr = rb_str_new2(attrs->name);
+
+		rb_funcall(rstr, ox_force_encoding_id, 1, 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
@@ -136,6 +145,10 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	    if (0 != pi->options->rb_enc) {
 		rb_enc_associate(rstr, pi->options->rb_enc);
 	    }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != pi->options->rb_enc) {
+		rb_funcall(rstr, ox_force_encoding_id, 1, pi->options->rb_enc);
+	    }
 #endif
 	    rb_hash_aset(ah, rstr, rb_str_new2(attrs->value));
 	}
@@ -143,6 +156,10 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	if (0 == strcmp("encoding", attrs->name)) {
 	    pi->options->rb_enc = rb_enc_find(attrs->value);
 	}
+#elif HAS_PRIVATE_ENCODING
+	if (0 == strcmp("encoding", attrs->name)) {
+	    pi->options->rb_enc = rb_str_new2(attrs->value);
+	}
 #endif
     }
     nodes = rb_ary_new();
@@ -212,6 +229,10 @@ add_doctype(PInfo pi, const char *docType) {
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+    }
 #endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (0 == pi->h) { /* top level object */
@@ -229,6 +250,10 @@ add_comment(PInfo pi, const char *comment) {
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+    }
 #endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (0 == pi->h) { /* top level object */
@@ -246,6 +271,10 @@ add_cdata(PInfo pi, const char *cdata, size_t len) {
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+    }
 #endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (0 == pi->h) { /* top level object */
@@ -262,6 +291,10 @@ add_text(PInfo pi, char *text, int closed) {
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+    }
 #endif
     if (0 == pi->h) { /* top level object */
 	create_doc(pi);
@@ -278,6 +311,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+    }
 #endif
     e = rb_obj_alloc(ox_element_clas);
     rb_ivar_set(e, ox_at_value_id, s);
@@ -299,6 +336,15 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		    } else {
 			sym = ID2SYM(rb_intern(attrs->name));
 		    }
+#elif HAS_PRIVATE_ENCODING
+		    if (Qnil != pi->options->rb_enc) {
+			VALUE	rstr = rb_str_new2(attrs->name);
+
+			rb_funcall(rstr, ox_force_encoding_id, 1, 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
@@ -310,6 +356,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		if (0 != pi->options->rb_enc) {
 		    rb_enc_associate(sym, pi->options->rb_enc);
 		}
+#elif HAS_PRIVATE_ENCODING
+		if (Qnil != pi->options->rb_enc) {
+		    rb_funcall(sym, ox_force_encoding_id, 1, pi->options->rb_enc);
+		}
 #endif
 	    }
             s = rb_str_new2(attrs->value);
@@ -317,6 +367,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
             if (0 != pi->options->rb_enc) {
                 rb_enc_associate(s, pi->options->rb_enc);
             }
+#elif HAS_PRIVATE_ENCODING
+            if (Qnil != pi->options->rb_enc) {
+		rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+            }
 #endif
             rb_hash_aset(ah, sym, s);
         }
@@ -364,6 +418,13 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 	    rb_enc_associate(c, pi->options->rb_enc);
 	}
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != pi->options->rb_enc) {
+	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+	if (0 != content) {
+	    rb_funcall(c, ox_force_encoding_id, 1, pi->options->rb_enc);
+	}
+    }
 #endif
     inst = rb_obj_alloc(ox_instruct_clas);
     rb_ivar_set(inst, ox_at_value_id, s);
@@ -387,6 +448,15 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 		    } else {
 			sym = ID2SYM(rb_intern(attrs->name));
 		    }
+#elif HAS_PRIVATE_ENCODING
+		    if (Qnil != pi->options->rb_enc) {
+			VALUE	rstr = rb_str_new2(attrs->name);
+
+			rb_funcall(rstr, ox_force_encoding_id, 1, 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
@@ -398,6 +468,10 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 		if (0 != pi->options->rb_enc) {
 		    rb_enc_associate(sym, pi->options->rb_enc);
 		}
+#elif HAS_PRIVATE_ENCODING
+		if (Qnil != pi->options->rb_enc) {
+		    rb_funcall(sym, ox_force_encoding_id, 1, pi->options->rb_enc);
+		}
 #endif
 	    }
             s = rb_str_new2(attrs->value);
@@ -405,6 +479,10 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
             if (0 != pi->options->rb_enc) {
                 rb_enc_associate(s, pi->options->rb_enc);
             }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != pi->options->rb_enc) {
+		rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
+	    }
 #endif
             rb_hash_aset(ah, sym, s);
         }

data/ext/ox/obj_load.c

@@ -183,6 +183,8 @@ structname2obj(const char *name) {
     /* use encoding as the indicator for Ruby 1.8.7 or 1.9.x */
 #if HAS_ENCODING_SUPPORT
     return rb_struct_alloc_noinit(ost);
+#elif HAS_PRIVATE_ENCODING
+    return rb_struct_alloc_noinit(ost);
 #else
     return rb_struct_new(ost);
 #endif
@@ -389,6 +391,15 @@ parse_regexp(const char *text) {
         default:                                                break;
         }
     }
+#elif HAS_PRIVATE_ENCODING
+    for (; text < te && '/' != *te; te--) {
+        switch (*te) {
+        case 'i':       options |= ONIG_OPTION_IGNORECASE;      break;
+        case 'm':       options |= ONIG_OPTION_MULTILINE;       break;
+        case 'x':       options |= ONIG_OPTION_EXTEND;          break;
+        default:                                                break;
+        }
+    }
 #endif
     return rb_reg_new(text + 1, te - text - 1, options);
 }
@@ -402,6 +413,12 @@ instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
                 pi->options->rb_enc = rb_enc_find(attrs->value);
             }
         }
+#elif HAS_PRIVATE_ENCODING
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("encoding", attrs->name)) {
+                pi->options->rb_enc = rb_str_new2(attrs->value);
+            }
+        }
 #endif
     }
 }
@@ -425,6 +442,10 @@ add_text(PInfo pi, char *text, int closed) {
         if (0 != pi->options->rb_enc) {
             rb_enc_associate(pi->h->obj, pi->options->rb_enc);
         }
+#elif HAS_PRIVATE_ENCODING
+        if (Qnil != pi->options->rb_enc) {
+	    rb_funcall(pi->h->obj, ox_force_encoding_id, 1, pi->options->rb_enc);
+        }
 #endif
         if (0 != pi->circ_array) {
             circ_array_set(pi->circ_array, pi->h->obj, (unsigned long)pi->id);
@@ -463,7 +484,7 @@ add_text(PInfo pi, char *text, int closed) {
         VALUE   *slot;
 
         if (Qundef == (sym = ox_cache_get(ox_symbol_cache, text, &slot))) {
-	    sym = str2sym(text, pi->options->rb_enc);
+	    sym = str2sym(text, (void*)pi->options->rb_enc);
             *slot = sym;
         }
         pi->h->obj = sym;
@@ -492,6 +513,10 @@ add_text(PInfo pi, char *text, int closed) {
         if (0 != pi->options->rb_enc) {
             rb_enc_associate(v, pi->options->rb_enc);
         }
+#elif HAS_PRIVATE_ENCODING
+        if (0 != pi->options->rb_enc) {
+	    rb_funcall(v, ox_force_encoding_id, 1, pi->options->rb_enc);
+        }
 #endif
         if (0 != pi->circ_array) {
             circ_array_set(pi->circ_array, v, (unsigned long)pi->h->obj);
@@ -508,7 +533,7 @@ add_text(PInfo pi, char *text, int closed) {
         
         from_base64(text, (uchar*)str);
         if (Qundef == (sym = ox_cache_get(ox_symbol_cache, str, &slot))) {
-	    sym = str2sym(str, pi->options->rb_enc);
+	    sym = str2sym(str, (void*)pi->options->rb_enc);
             *slot = sym;
         }
         pi->h->obj = sym;
@@ -572,7 +597,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     }
     h = pi->h;
     h->type = *ename;
-    h->var = get_var_sym_from_attrs(attrs, pi->options->rb_enc);
+    h->var = get_var_sym_from_attrs(attrs, (void*)pi->options->rb_enc);
     switch (h->type) {
     case NilClassCode:
         h->obj = Qnil;

data/ext/ox/ox.c

@@ -66,6 +66,7 @@ ID	ox_error_id;
 ID	ox_excl_id;
 ID	ox_external_encoding_id;
 ID	ox_fileno_id;
+ID	ox_force_encoding_id;
 ID	ox_inspect_id;
 ID	ox_instruct_id;
 ID	ox_jd_id;
@@ -134,6 +135,8 @@ static VALUE	xsd_date_sym;
 
 #if HAS_ENCODING_SUPPORT
 rb_encoding	*ox_utf8_encoding = 0;
+#elif HAS_PRIVATE_ENCODING
+VALUE		ox_utf8_encoding = Qnil;
 #else
 void		*ox_utf8_encoding = 0;
 #endif
@@ -150,7 +153,11 @@ struct _Options	 ox_default_options = {
     NoMode,		/* mode */
     StrictEffort,	/* effort */
     Yes,		/* sym_keys */
+#if HAS_PRIVATE_ENCODING
+    Qnil		/* rb_enc */
+#else
     0			/* rb_enc */
+#endif
 };
 
 extern ParseCallbacks	ox_obj_callbacks;
@@ -297,6 +304,9 @@ set_def_opts(VALUE self, VALUE opts) {
 	strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
 #ifdef HAVE_RUBY_ENCODING_H
 	ox_default_options.rb_enc = rb_enc_find(ox_default_options.encoding);
+#elif HAS_PRIVATE_ENCODING
+	ox_default_options.rb_enc = rb_str_new2(ox_default_options.encoding);
+	rb_gc_register_address(&ox_default_options.rb_enc);
 #endif
     }
 
@@ -468,6 +478,17 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding) {
     } else if (0 == options.rb_enc) {
 	options.rb_enc = rb_enc_find(options.encoding);
     }
+#elif HAS_PRIVATE_ENCODING
+    if ('\0' == *options.encoding) {
+	if (Qnil != encoding) {
+	    options.rb_enc = encoding;
+	} else {
+	    options.rb_enc = Qnil;
+	}
+    } else if (0 == options.rb_enc) {
+	options.rb_enc = rb_str_new2(options.encoding);
+	rb_gc_register_address(&options.rb_enc);
+    }
 #endif
     xml = defuse_bom(xml, &options);
     switch (options.mode) {
@@ -525,6 +546,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
     }
 #ifdef HAVE_RUBY_ENCODING_H
     encoding = rb_obj_encoding(*argv);
+#elif HAS_PRIVATE_ENCODING
+    encoding = rb_funcall(*argv, rb_intern("encoding"), 0);
 #else
     encoding = Qnil;
 #endif
@@ -706,6 +729,10 @@ dump(int argc, VALUE *argv, VALUE self) {
     if ('\0' != *copts.encoding) {
 	rb_enc_associate(rstr, rb_enc_find(copts.encoding));
     }
+#elif HAS_PRIVATE_ENCODING
+    if ('\0' != *copts.encoding) {
+	rb_funcall(rstr, ox_force_encoding_id, 1, rb_str_new2(copts.encoding));
+    }
 #endif
     xfree(xml);
 
@@ -793,6 +820,7 @@ void Init_ox() {
     ox_error_id = rb_intern("error");
     ox_excl_id = rb_intern("@excl");
     ox_fileno_id = rb_intern("fileno");
+    ox_force_encoding_id = rb_intern("force_encoding");
     ox_inspect_id = rb_intern("inspect");
     ox_instruct_id = rb_intern("instruct");
     ox_jd_id = rb_intern("jd");
@@ -864,6 +892,8 @@ void Init_ox() {
     rb_define_module_function(Ox, "cache8_test", cache8_test, 0);
 #if HAS_ENCODING_SUPPORT
     ox_utf8_encoding = rb_enc_find("UTF-8");
+#elif HAS_PRIVATE_ENCODING
+    ox_utf8_encoding = rb_str_new2("UTF-8");			rb_gc_register_address(&ox_utf8_encoding);
 #endif
 }
 

data/ext/ox/ox.h

@@ -188,6 +188,8 @@ typedef struct _Options {
     char	sym_keys;	/* symbolize keys */
 #ifdef HAVE_RUBY_ENCODING_H
     rb_encoding	*rb_enc;
+#elif HAS_PRIVATE_ENCODING
+    VALUE	rb_enc;
 #else
     void	*rb_enc;
 #endif
@@ -238,6 +240,7 @@ extern ID	ox_error_id;
 extern ID	ox_excl_id;
 extern ID	ox_external_encoding_id;
 extern ID	ox_fileno_id;
+extern ID	ox_force_encoding_id;
 extern ID	ox_inspect_id;
 extern ID	ox_instruct_id;
 extern ID	ox_jd_id;
@@ -263,6 +266,8 @@ extern ID	ox_value_id;
 
 #if HAS_ENCODING_SUPPORT
 extern rb_encoding	*ox_utf8_encoding;
+#elif HAS_PRIVATE_ENCODING
+extern VALUE		ox_utf8_encoding;
 #else
 extern void		*ox_utf8_encoding;
 #endif

data/ext/ox/parse.c

@@ -828,9 +828,18 @@ read_coded_chars(PInfo pi, char *text) {
 	    pi->s = s;
 	    if (u <= 0x000000000000007FULL) {
 		*text++ = (char)u;
+#if HAS_PRIVATE_ENCODING
+	    } else if (ox_utf8_encoding == pi->options->rb_enc ||
+		       0 == strcasecmp(rb_str_ptr(rb_String(ox_utf8_encoding)), rb_str_ptr(rb_String(pi->options->rb_enc)))) {
+#else
 	    } else if (ox_utf8_encoding == pi->options->rb_enc) {
+#endif
 		text = ucs_to_utf8_chars(text, u);
+#if HAS_PRIVATE_ENCODING
+	    } else if (Qnil == pi->options->rb_enc) {
+#else
 	    } else if (0 == pi->options->rb_enc) {
+#endif
 		pi->options->rb_enc = ox_utf8_encoding;
 		text = ucs_to_utf8_chars(text, u);
 	    } else {
@@ -888,10 +897,19 @@ collapse_special(PInfo pi, char *str) {
 		}
 		if (u <= 0x000000000000007FULL) {
 		    *b++ = (char)u;
+#if HAS_PRIVATE_ENCODING
+		} else if (ox_utf8_encoding == pi->options->rb_enc ||
+			   0 == strcasecmp(rb_str_ptr(rb_String(ox_utf8_encoding)), rb_str_ptr(rb_String(pi->options->rb_enc)))) {
+#else
 		} else if (ox_utf8_encoding == pi->options->rb_enc) {
+#endif
 		    b = ucs_to_utf8_chars(b, u);
 		    /* TBD support UTF-16 */
+#if HAS_PRIVATE_ENCODING
+		} else if (Qnil == pi->options->rb_enc) {
+#else
 		} else if (0 == pi->options->rb_enc) {
+#endif
 		    pi->options->rb_enc = ox_utf8_encoding;
 		    b = ucs_to_utf8_chars(b, u);
 		} else {

data/ext/ox/sax.c

@@ -74,6 +74,8 @@ typedef struct _SaxDrive {
     int         has_error;
 #if HAS_ENCODING_SUPPORT
     rb_encoding *encoding;
+#elif HAS_PRIVATE_ENCODING
+    VALUE	encoding;
 #endif
 } *SaxDrive;
 
@@ -214,6 +216,15 @@ str2sym(const char *str, SaxDrive dr) {
         } else {
 	    sym = ID2SYM(rb_intern(str));
 	}
+#elif HAS_PRIVATE_ENCODING
+        if (Qnil != dr->encoding) {
+	    VALUE	rstr = rb_str_new2(str);
+
+	    rb_funcall(rstr, ox_force_encoding_id, 1, dr->encoding);
+	    sym = rb_funcall(rstr, ox_to_sym_id, 0);
+        } else {
+	    sym = ID2SYM(rb_intern(str));
+	}
 #else
         sym = ID2SYM(rb_intern(str));
 #endif
@@ -339,6 +350,18 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
     } else {
         dr->encoding = rb_enc_find(ox_default_options.encoding);
     }
+#elif HAS_PRIVATE_ENCODING
+    if ('\0' == *ox_default_options.encoding) {
+	VALUE	encoding;
+
+	if (rb_respond_to(io, ox_external_encoding_id) && Qnil != (encoding = rb_funcall(io, ox_external_encoding_id, 0))) {
+	    dr->encoding = encoding;
+	} else {
+	    dr->encoding = Qnil;
+	}
+    } else {
+        dr->encoding = rb_str_new2(ox_default_options.encoding);
+    }
 #endif
 }
 
@@ -412,7 +435,6 @@ static int
 read_children(SaxDrive dr, int first) {
     int         err = 0;
     int         element_read = !first;
-    int         doctype_read = !first;
     char        c;
     
     while (!err) {
@@ -423,6 +445,8 @@ read_children(SaxDrive dr, int first) {
 		if (0xBB == (uint8_t)sax_drive_get(dr) && 0xBF == (uint8_t)sax_drive_get(dr)) {
 #if HAS_ENCODING_SUPPORT
 		    dr->encoding = ox_utf8_encoding;
+#elif HAS_PRIVATE_ENCODING
+		    dr->encoding = ox_utf8_encoding;
 #endif
 		    c = sax_drive_get(dr);
 		} else {
@@ -477,7 +501,6 @@ read_children(SaxDrive dr, int first) {
                     if (element_read || !first) {
                         sax_drive_error(dr, "invalid format, DOCTYPE can not come after an element", 0);
                     }
-                    doctype_read = 1;
                     err = read_doctype(dr);
                 } else if (0 == strncmp("[CDATA[", dr->str, 7)) {
                     err = read_cdata(dr);
@@ -575,6 +598,10 @@ read_instruction(SaxDrive dr) {
 	    if (0 != dr->encoding) {
 		rb_enc_associate(args[0], dr->encoding);
 	    }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != dr->encoding) {
+		rb_funcall(args[0], ox_force_encoding_id, 1, dr->encoding);
+	    }
 #endif
 	    rb_funcall2(dr->handler, ox_text_id, 1, args);
 	}
@@ -656,6 +683,10 @@ read_cdata(SaxDrive dr) {
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
+#elif HAS_PRIVATE_ENCODING
+        if (Qnil != dr->encoding) {
+	    rb_funcall(args[0], ox_force_encoding_id, 1, dr->encoding);
+        }
 #endif
         rb_funcall2(dr->handler, ox_cdata_id, 1, args);
     }
@@ -700,6 +731,10 @@ read_comment(SaxDrive dr) {
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
+#elif HAS_PRIVATE_ENCODING
+        if (Qnil != dr->encoding) {
+	    rb_funcall(args[0], ox_force_encoding_id, 1, dr->encoding);
+        }
 #endif
         rb_funcall2(dr->handler, ox_comment_id, 1, args);
     }
@@ -716,11 +751,13 @@ read_element(SaxDrive dr) {
     VALUE       name = Qnil;
     const char	*err;
     char        c;
+    char	*ename = 0;
     int         closed;
 
     if ('\0' == (c = read_name_token(dr))) {
         return -1;
     }
+    ename = dr->str;
     name = str2sym(dr->str, dr);
     if (dr->has_start_element) {
         VALUE       args[1];
@@ -757,7 +794,7 @@ read_element(SaxDrive dr) {
         if (0 != read_children(dr, 0)) {
             return -1;
         }
-        if (0 != strcmp(dr->str, rb_id2name(SYM2ID(name)))) {
+        if (0 != strcmp(dr->str, ename)) {
             sax_drive_error(dr, "invalid format, element start and end names do not match", 1);
             return -1;
         }
@@ -804,6 +841,10 @@ read_text(SaxDrive dr) {
         if (0 != dr->encoding) {
             rb_enc_associate(args[0], dr->encoding);
         }
+#elif HAS_PRIVATE_ENCODING
+        if (Qnil != dr->encoding) {
+	    rb_funcall(args[0], ox_force_encoding_id, 1, dr->encoding);
+        }
 #endif
         rb_funcall2(dr->handler, ox_text_id, 1, args);
     }
@@ -848,6 +889,8 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
         if (is_encoding) {
 #if HAS_ENCODING_SUPPORT
             dr->encoding = rb_enc_find(dr->str);
+#elif HAS_PRIVATE_ENCODING
+	    dr->encoding = rb_str_new2(dr->str);
 #endif
             is_encoding = 0;
         }
@@ -869,6 +912,10 @@ read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
             if (0 != dr->encoding) {
                 rb_enc_associate(args[1], dr->encoding);
             }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != dr->encoding) {
+		rb_funcall(args[1], ox_force_encoding_id, 1, dr->encoding);
+	    }
 #endif
             rb_funcall2(dr->handler, ox_attr_id, 2, args);
         }
@@ -1216,6 +1263,10 @@ sax_value_as_s(VALUE self) {
     if (0 != dr->encoding) {
 	rb_enc_associate(rs, dr->encoding);
     }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != dr->encoding) {
+	rb_funcall(rs, ox_force_encoding_id, 1, dr->encoding);
+    }
 #endif
     return rs;
 }

data/lib/ox/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 1.8.4
+  version: 1.8.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-02-03 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