ox 2.12.1 → 2.14.0

data/ext/ox/hash_load.c

@@ -74,19 +74,14 @@ unmark(PInfo pi, VALUE val) {
 }
 
 static void
-add_text(PInfo pi, char *text, int closed) {
+add_str(PInfo pi, VALUE s) {
     Helper		parent = helper_stack_peek(&pi->helpers);
-    volatile VALUE	s = rb_str_new2(text);
     volatile VALUE	a;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     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
     switch (parent->type) {
     case NoCode:
@@ -106,6 +101,16 @@ add_text(PInfo pi, char *text, int closed) {
     }
 }
 
+static void
+add_text(PInfo pi, char *text, int closed) {
+    add_str(pi, rb_str_new2(text));
+}
+
+static void
+add_cdata(PInfo pi, const char *text, size_t len) {
+    add_str(pi, rb_str_new(text, len));
+}
+
 static void
 add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (helper_stack_empty(&pi->helpers)) {
@@ -126,14 +131,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		key = rb_str_new2(attrs->name);
 	    }
 	    val = rb_str_new2(attrs->value);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	    if (0 != pi->options->rb_enc) {
 		rb_enc_associate(val, pi->options->rb_enc);
 	    }
-#elif HAS_PRIVATE_ENCODING
-	    if (Qnil != pi->options->rb_enc) {
-		rb_funcall(val, ox_force_encoding_id, 1, pi->options->rb_enc);
-	    }
 #endif
 	    rb_hash_aset(h, key, val);
 	}
@@ -258,6 +259,19 @@ struct _parseCallbacks   _ox_hash_callbacks = {
 
 ParseCallbacks   ox_hash_callbacks = &_ox_hash_callbacks;
 
+struct _parseCallbacks   _ox_hash_cdata_callbacks = {
+    NULL,
+    NULL,
+    NULL,
+    add_cdata,
+    add_text,
+    add_element,
+    end_element,
+    finish,
+};
+
+ParseCallbacks   ox_hash_cdata_callbacks = &_ox_hash_cdata_callbacks;
+
 struct _parseCallbacks   _ox_hash_no_attrs_callbacks = {
     NULL,
     NULL,
@@ -270,3 +284,16 @@ struct _parseCallbacks   _ox_hash_no_attrs_callbacks = {
 };
 
 ParseCallbacks   ox_hash_no_attrs_callbacks = &_ox_hash_no_attrs_callbacks;
+
+struct _parseCallbacks   _ox_hash_no_attrs_cdata_callbacks = {
+    NULL,
+    NULL,
+    NULL,
+    add_cdata,
+    add_text,
+    add_element_no_attrs,
+    end_element_no_attrs,
+    NULL,
+};
+
+ParseCallbacks   ox_hash_no_attrs_cdata_callbacks = &_ox_hash_no_attrs_cdata_callbacks;

data/ext/ox/obj_load.c

@@ -11,6 +11,9 @@
 #include <time.h>
 
 #include "ruby.h"
+#if HAVE_RB_ENC_ASSOCIATE
+#include "ruby/encoding.h"
+#endif
 #include "base64.h"
 #include "ox.h"
 
@@ -143,7 +146,6 @@ classname2obj(const char *name, PInfo pi, VALUE base_class) {
     }
 }
 
-#if HAS_RSTRUCT
 inline static VALUE
 structname2obj(const char *name) {
     VALUE	ost;
@@ -159,16 +161,12 @@ structname2obj(const char *name) {
 	}
     }
     ost = rb_const_get(ox_struct_class, rb_intern(s));
-    /* 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
+#if HAVE_RB_STRUCT_ALLOC_NOINIT
     return rb_struct_alloc_noinit(ost);
 #else
     return rb_struct_new(ost);
 #endif
 }
-#endif
 
 inline static VALUE
 parse_ulong(const char *s, PInfo pi) {
@@ -239,6 +237,7 @@ static ID
 get_var_sym_from_attrs(Attr a, void *encoding) {
     for (; 0 != a->name; a++) {
 	if ('a' == *a->name && '\0' == *(a->name + 1)) {
+	    name2var(a->value, encoding);
 	    return name2var(a->value, encoding);
 	}
     }
@@ -255,7 +254,6 @@ get_obj_from_attrs(Attr a, PInfo pi, VALUE base_class) {
     return Qundef;
 }
 
-#if HAS_RSTRUCT
 static VALUE
 get_struct_from_attrs(Attr a) {
     for (; 0 != a->name; a++) {
@@ -265,7 +263,6 @@ get_struct_from_attrs(Attr a) {
     }
     return Qundef;
 }
-#endif
 
 static VALUE
 get_class_from_attrs(Attr a, PInfo pi, VALUE base_class) {
@@ -363,7 +360,7 @@ parse_regexp(const char *text) {
     int		options = 0;
 
     te = text + strlen(text) - 1;
-#if HAS_ONIG
+#ifdef ONIG_OPTION_IGNORECASE
     for (; text < te && '/' != *te; te--) {
 	switch (*te) {
 	case 'i':	options |= ONIG_OPTION_IGNORECASE;	break;
@@ -379,18 +376,12 @@ parse_regexp(const char *text) {
 static void
 instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
 	for (; 0 != attrs->name; attrs++) {
 	    if (0 == strcmp("encoding", attrs->name)) {
 		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
     }
 }
@@ -417,14 +408,10 @@ add_text(PInfo pi, char *text, int closed) {
     case NoCode:
     case StringCode:
 	h->obj = rb_str_new2(text);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	if (0 != pi->options->rb_enc) {
 	    rb_enc_associate(h->obj, pi->options->rb_enc);
 	}
-#elif HAS_PRIVATE_ENCODING
-	if (Qnil != pi->options->rb_enc) {
-	    rb_funcall(h->obj, ox_force_encoding_id, 1, pi->options->rb_enc);
-	}
 #endif
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, h->obj, (unsigned long)pi->id);
@@ -494,14 +481,10 @@ add_text(PInfo pi, char *text, int closed) {
 
 	from_base64(text, (uchar*)str);
 	v = rb_str_new(str, str_size);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	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)h->obj);
@@ -542,11 +525,7 @@ add_text(PInfo pi, char *text, int closed) {
 	h->obj = rb_cstr_to_inum(text, 10, 1);
 	break;
     case BigDecimalCode:
-#if HAS_BIGDECIMAL
 	h->obj = rb_funcall(rb_cObject, ox_bigdecimal_id, 1, rb_str_new2(text));
-#else
-	h->obj = Qnil;
-#endif
 	break;
     default:
 	h->obj = Qnil;
@@ -670,15 +649,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 	}
 	break;
     case StructCode:
-#if HAS_RSTRUCT
 	h->obj = get_struct_from_attrs(attrs);
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, h->obj, get_id_from_attrs(pi, attrs));
 	}
-#else
-	set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-	return;
-#endif
 	break;
     case ClassCode:
 	if (Qundef == (h->obj = get_class_from_attrs(attrs, pi, ox_bag_clas))) {
@@ -742,31 +716,29 @@ end_element(PInfo pi, const char *ename) {
 	    case ExceptionCode:
 	    case ObjectCode:
 		if (Qnil != ph->obj) {
-		    if (0 == h->var) {
+		    if (0 == h->var || NULL == rb_id2name(h->var )) {
 			set_error(&pi->err, "Invalid element for object mode", pi->str, pi->s);
 			return;
 		    }
+		    if (RUBY_T_OBJECT != rb_type(ph->obj)) {
+			set_error(&pi->err, "Corrupt object encoding", pi->str, pi->s);
+			return;
+		    }
 		    rb_ivar_set(ph->obj, h->var, h->obj);
 		}
 		break;
 	    case StructCode:
-#if HAS_RSTRUCT
 		if (0 == h->var) {
 		    set_error(&pi->err, "Invalid element for object mode", pi->str, pi->s);
 		    return;
 		}
 		rb_struct_aset(ph->obj, h->var, h->obj);
-#else
-		set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-		return;
-#endif
 		break;
 	    case HashCode:
 		// put back h
 		helper_stack_push(&pi->helpers, h->var, h->obj, KeyCode);
 		break;
 	    case RangeCode:
-#if HAS_RSTRUCT
 		if (ox_beg_id == h->var) {
 		    RSTRUCT_SET(ph->obj, 0, h->obj);
 		} else if (ox_end_id == h->var) {
@@ -777,10 +749,6 @@ end_element(PInfo pi, const char *ename) {
 		    set_error(&pi->err, "Invalid range attribute", pi->str, pi->s);
 		    return;
 		}
-#else
-		set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-		return;
-#endif
 		break;
 	    case KeyCode:
 		{

data/ext/ox/ox.c

@@ -145,6 +145,7 @@ static VALUE	symbolize_keys_sym;
 static VALUE	symbolize_sym;
 static VALUE	tolerant_sym;
 static VALUE	trace_sym;
+static VALUE	with_cdata_sym;
 static VALUE	with_dtd_sym;
 static VALUE	with_instruct_sym;
 static VALUE	with_xml_sym;
@@ -154,10 +155,8 @@ static VALUE 	element_key_mod_sym;
 static ID	encoding_id;
 static ID	has_key_id;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 rb_encoding	*ox_utf8_encoding = 0;
-#elif HAS_PRIVATE_ENCODING
-VALUE		ox_utf8_encoding = Qnil;
 #else
 void		*ox_utf8_encoding = 0;
 #endif
@@ -181,16 +180,13 @@ struct _options	 ox_default_options = {
     true,		// convert_special
     No,			// allow_invalid
     false,		// no_empty
+    false,		// with_cdata
     { '\0' },		// inv_repl
     { '\0' },		// strip_ns
     NULL,		// html_hints
     Qnil,		// attr_key_mod;
     Qnil,		// element_key_mod;
-#if HAS_PRIVATE_ENCODING
-    Qnil		// rb_enc
-#else
     0			// rb_enc
-#endif
 };
 
 extern ParseCallbacks	ox_obj_callbacks;
@@ -198,7 +194,9 @@ extern ParseCallbacks	ox_gen_callbacks;
 extern ParseCallbacks	ox_limited_callbacks;
 extern ParseCallbacks	ox_nomode_callbacks;
 extern ParseCallbacks	ox_hash_callbacks;
+extern ParseCallbacks	ox_hash_cdata_callbacks;
 extern ParseCallbacks	ox_hash_no_attrs_callbacks;
+extern ParseCallbacks	ox_hash_no_attrs_cdata_callbacks;
 
 static void	parse_dump_options(VALUE ropts, Options copts);
 
@@ -296,6 +294,7 @@ hints_to_overlay(Hints hints) {
  * - _:convert_special_ [true|false|nil] flag indicating special characters like < are converted with the SAX parser
  * - _:invalid_replace_ [nil|String] replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
  * - _:no_empty_ [true|false|nil] flag indicating there should be no empty elements in a dump
+ * - _:with_cdata_ [true|false] includes cdata in hash_load results
  * - _:strip_namespace_ [String|true|false] false or "" results in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  * - _:overlay_ [Hash] a Hash of keys that match html element names and values that are one of
  *   - _:active_ - make the normal callback for the element
@@ -330,6 +329,7 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, smart_sym, (Yes == ox_default_options.smart) ? Qtrue : ((No == ox_default_options.smart) ? Qfalse : Qnil));
     rb_hash_aset(opts, convert_special_sym, (ox_default_options.convert_special) ? Qtrue : Qfalse);
     rb_hash_aset(opts, no_empty_sym, (ox_default_options.no_empty) ? Qtrue : Qfalse);
+    rb_hash_aset(opts, with_cdata_sym, (ox_default_options.with_cdata) ? Qtrue : Qfalse);
     switch (ox_default_options.mode) {
     case ObjMode:		rb_hash_aset(opts, mode_sym, object_sym);		break;
     case GenMode:		rb_hash_aset(opts, mode_sym, generic_sym);		break;
@@ -437,6 +437,7 @@ sax_html_overlay(VALUE self) {
  *   - _:smart_ [true|false|nil] flag indicating the SAX parser uses hints if available (use with html)
  *   - _:invalid_replace_ [nil|String] replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
  *   - _:strip_namespace_ [nil|String|true|false] "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
+ * - _:with_cdata_ [true|false] includes cdata in hash_load results
  * - _:overlay_ [Hash] a Hash of keys that match html element names and values that are one of
  *   - _:active_ - make the normal callback for the element
  *   - _:nest_ok_ - active but ignore nest check
@@ -470,11 +471,8 @@ set_def_opts(VALUE self, VALUE opts) {
     } else {
 	Check_Type(v, T_STRING);
 	strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
 	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
     }
 
@@ -639,6 +637,10 @@ set_def_opts(VALUE self, VALUE opts) {
 	    rb_hash_foreach(v, set_overlay, (VALUE)ox_default_options.html_hints);
 	}
     }
+    if (Qnil != (v = rb_hash_lookup(opts, with_cdata_sym))) {
+	ox_default_options.with_cdata = (Qtrue == v);
+    }
+
     ox_default_options.element_key_mod = rb_hash_lookup2(opts, element_key_mod_sym, ox_default_options.element_key_mod);
     ox_default_options.attr_key_mod = rb_hash_lookup2(opts, attr_key_mod_sym, ox_default_options.attr_key_mod);
 
@@ -674,14 +676,14 @@ to_obj(VALUE self, VALUE ruby_xml) {
 	xml = ALLOCA_N(char, len);
     }
     memcpy(xml, x, len);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_disable();
 #endif
     obj = ox_parse(xml, len - 1, ox_obj_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     RB_GC_GUARD(obj);
     rb_gc_enable();
 #endif
@@ -847,8 +849,11 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
 	    options.margin[sizeof(options.margin) - 1] = '\0';
 	    options.margin_len = strlen(options.margin);
 	}
+	if (Qnil != (v = rb_hash_lookup(h, with_cdata_sym))) {
+	    options.with_cdata = (Qtrue == v);
+	}
     }
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     if ('\0' == *options.encoding) {
 	if (Qnil != encoding) {
 	    options.rb_enc = rb_enc_from_index(rb_enc_get_index(encoding));
@@ -858,26 +863,15 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
     } 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) {
     case ObjMode:
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	rb_gc_disable();
 #endif
 	obj = ox_parse(xml, len, ox_obj_callbacks, 0, &options, err);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	RB_GC_GUARD(obj);
 	rb_gc_enable();
 #endif
@@ -889,10 +883,18 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
 	obj = ox_parse(xml, len, ox_limited_callbacks, 0, &options, err);
 	break;
     case HashMode:
-	obj = ox_parse(xml, len, ox_hash_callbacks, 0, &options, err);
+	if (options.with_cdata) {
+	    obj = ox_parse(xml, len, ox_hash_cdata_callbacks, 0, &options, err);
+	} else {
+	    obj = ox_parse(xml, len, ox_hash_callbacks, 0, &options, err);
+	}
 	break;
     case HashNoAttrMode:
-	obj = ox_parse(xml, len, ox_hash_no_attrs_callbacks, 0, &options, err);
+	if (options.with_cdata) {
+	    obj = ox_parse(xml, len, ox_hash_no_attrs_cdata_callbacks, 0, &options, err);
+	} else {
+	    obj = ox_parse(xml, len, ox_hash_no_attrs_callbacks, 0, &options, err);
+	}
 	break;
     case NoMode:
 	obj = ox_parse(xml, len, ox_nomode_callbacks, 0, &options, err);
@@ -928,6 +930,7 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
  *   - *:symbolize_keys* [true|false|nil] symbolize element attribute keys or leave as Strings
  *   - *:invalid_replace* [nil|String] replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
  *   - *:strip_namespace* [String|true|false] "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
+ *   - *:with_cdata* [true|false] if true cdata is included in hash_load output otherwise it is not.
  */
 static VALUE
 load_str(int argc, VALUE *argv, VALUE self) {
@@ -946,14 +949,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
     } else {
 	xml = ALLOCA_N(char, len);
     }
-#if HAS_ENCODING_SUPPORT
-#ifdef MACRUBY_RUBY
-    encoding = rb_funcall(*argv, encoding_id, 0);
-#else
+#if HAVE_RB_OBJ_ENCODING
     encoding = rb_obj_encoding(*argv);
-#endif
-#elif HAS_PRIVATE_ENCODING
-    encoding = rb_funcall(*argv, encoding_id, 0);
 #else
     encoding = Qnil;
 #endif
@@ -1319,21 +1316,38 @@ dump(int argc, VALUE *argv, VALUE self) {
 	rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(xml);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     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);
 
     return rstr;
 }
 
-/* call-seq: to_file(file_path, obj, options)
+/* call-seq: to_xml(obj, options) => xml-string
+ *
+ * Dumps an Object (obj) to a string.
+ * - +obj+ [Object] Object to serialize as an XML document String
+ * - +options+ [Hash] formating options
+ *   - *:indent* [Fixnum] format expected
+ *   - *:no_empty* [true|false] if true don't output empty elements
+ *   - *:xsd_date* [true|false] use XSD date format if true, default: false
+ *   - *:circular* [true|false] allow circular references, default: false
+ *   - *:strict|:tolerant]* [ :effort effort to use when an undumpable object (e.g., IO) is encountered, default: :strict
+ *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
+ *     - _:tolerant_ - replaces undumplable objects with nil
+ *
+ * Note that an indent of less than zero will result in a tight one line output
+ * unless the text in the XML fields contain new line characters.
+ */
+static VALUE
+to_xml(int argc, VALUE *argv, VALUE self) {
+    return dump(argc, argv, self);
+}
+
+/* call-seq: to_file(file_path, obj, options) => Object
  *
  * Dumps an Object to the specified file.
  * - +file_path+ [String] file path to write the XML document to
@@ -1392,7 +1406,7 @@ void Init_ox() {
     rb_define_module_function(Ox, "sax_parse", sax_parse, -1);
     rb_define_module_function(Ox, "sax_html", sax_html, -1);
 
-    rb_define_module_function(Ox, "to_xml", dump, -1);
+    rb_define_module_function(Ox, "to_xml", to_xml, -1);
     rb_define_module_function(Ox, "dump", dump, -1);
 
     rb_define_module_function(Ox, "load_file", load_file, -1);
@@ -1525,6 +1539,7 @@ void Init_ox() {
     symbolize_sym = ID2SYM(rb_intern("symbolize"));		rb_gc_register_address(&symbolize_sym);
     tolerant_sym = ID2SYM(rb_intern("tolerant"));		rb_gc_register_address(&tolerant_sym);
     trace_sym = ID2SYM(rb_intern("trace"));			rb_gc_register_address(&trace_sym);
+    with_cdata_sym = ID2SYM(rb_intern("with_cdata"));		rb_gc_register_address(&with_cdata_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);
@@ -1555,11 +1570,8 @@ void Init_ox() {
     rb_define _module_function(Ox, "cache8_test", cache8_test, 0);
 #endif
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     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
 }
 
@@ -1580,7 +1592,7 @@ _ox_raise_error(const char *msg, const char *xml, const char *current, const cha
 	    xline++;
 	}
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_enable();
 #endif
     rb_raise(ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);