ox 2.11.0 → 2.13.3

data/ext/ox/gen_load.c

@@ -10,6 +10,9 @@
 #include <stdarg.h>
 
 #include "ruby.h"
+#if HAVE_RB_ENC_ASSOCIATE
+#include "ruby/encoding.h"
+#endif
 #include "ox.h"
 
 static void     instruct(PInfo pi, const char *target, Attr attrs, const char *content);
@@ -72,7 +75,7 @@ create_doc(PInfo pi) {
 
     helper_stack_init(&pi->helpers);
     doc = rb_obj_alloc(ox_document_clas);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     RB_GC_GUARD(doc);
 #endif
     nodes = rb_ary_new();
@@ -100,7 +103,7 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	    sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
 	    rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
 	} else if (Yes == pi->options->sym_keys) {
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	    if (0 != pi->options->rb_enc) {
 		VALUE	rstr = rb_str_new2(attrs->name);
 
@@ -109,41 +112,21 @@ 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
 	    rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
 	} else {
 	    volatile VALUE	rstr = rb_str_new2(attrs->name);
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	    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));
 	}
-#if HAS_ENCODING_SUPPORT
 	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,14 +195,10 @@ add_doctype(PInfo pi, const char *docType) {
     VALUE       n = rb_obj_alloc(ox_doctype_clas);
     VALUE       s = rb_str_new2(docType);
 
-#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
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
@@ -233,14 +212,10 @@ add_comment(PInfo pi, const char *comment) {
     VALUE       n = rb_obj_alloc(ox_comment_clas);
     VALUE       s = rb_str_new2(comment);
 
-#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
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
@@ -254,14 +229,10 @@ add_cdata(PInfo pi, const char *cdata, size_t len) {
     VALUE       n = rb_obj_alloc(ox_cdata_clas);
     VALUE       s = rb_str_new2(cdata);
 
-#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
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
@@ -274,14 +245,10 @@ static void
 add_text(PInfo pi, char *text, int closed) {
     VALUE       s = rb_str_new2(text);
 
-#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
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
 	create_doc(pi);
@@ -297,14 +264,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (Qnil != pi->options->element_key_mod) {
 	s = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, s);
     }
-#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
     e = rb_obj_alloc(ox_element_clas);
     rb_ivar_set(e, ox_at_value_id, s);
@@ -320,7 +283,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		VALUE	*slot;
 
 		if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot, 0))) {
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 		    if (0 != pi->options->rb_enc) {
 			VALUE	rstr = rb_str_new2(attrs->name);
 
@@ -329,15 +292,6 @@ 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
@@ -348,25 +302,17 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		}
 	    } else {
 		sym = rb_str_new2(attrs->name);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 		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);
-#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
             rb_hash_aset(ah, sym, s);
         }
@@ -403,20 +349,13 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
     if (0 != content) {
 	c = rb_str_new2(content);
     }
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     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);
 	}
     }
-#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);
@@ -433,7 +372,7 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 		sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
 	    } else if (Yes == pi->options->sym_keys) {
 		if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot, 0))) {
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 		    if (0 != pi->options->rb_enc) {
 			VALUE	rstr = rb_str_new2(attrs->name);
 
@@ -442,15 +381,6 @@ 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
@@ -461,25 +391,17 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 		}
 	    } else {
 		sym = rb_str_new2(attrs->name);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 		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);
-#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
             rb_hash_aset(ah, sym, s);
         }

data/ext/ox/hash_load.c

@@ -13,12 +13,14 @@
 #include "ruby.h"
 #include "ox.h"
 
+#define MARK_INC	256
+
 // The approach taken for the hash and has_no_attrs parsing is to push just
 // the key on to the stack and then decide what to do on the way up/out.
 
 static VALUE
 create_top(PInfo pi) {
-    volatile VALUE       top = rb_hash_new();;
+    volatile VALUE       top = rb_hash_new();
 
     helper_stack_push(&pi->helpers, 0, top, HashCode);
     pi->obj = top;
@@ -26,20 +28,61 @@ create_top(PInfo pi) {
     return top;
 }
 
+static void
+mark_value(PInfo pi, VALUE val) {
+    if (NULL == pi->marked) {
+	pi->marked = ALLOC_N(VALUE, MARK_INC);
+	pi->mark_size = MARK_INC;
+    } else if (pi->mark_size <= pi->mark_cnt) {
+	pi->mark_size += MARK_INC;
+	pi->marked = REALLOC_N(pi->marked, VALUE, pi->mark_size);
+    }
+    pi->marked[pi->mark_cnt] = val;
+    pi->mark_cnt++;
+}
+
+static bool
+marked(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
+
+	for (; pi->marked <= vp; vp--) {
+	    if (val == *vp) {
+		return true;
+	    }
+	}
+    }
+    return false;
+}
+
+static void
+unmark(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
+	int		i;
+
+	for (i = 0; pi->marked <= vp; vp--, i++) {
+	    if (val == *vp) {
+		for (; 0 < i; i--, vp++) {
+		    *vp = *(vp + 1);
+		}
+		pi->mark_cnt--;
+		break;
+	    }
+	}
+    }
+}
+
 static void
 add_text(PInfo pi, char *text, int closed) {
     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:
@@ -79,20 +122,16 @@ 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);
 	}
 	a = rb_ary_new();
 	rb_ary_push(a, h);
-	rb_obj_taint(a); // flag indicating it is a unit, kind of a hack but it works
+	mark_value(pi, a);
 	helper_stack_push(&pi->helpers, rb_intern(ename), a, ArrayCode);
     } else {
 	helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
@@ -108,15 +147,14 @@ add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 }
 
 static int
-untaint_hash_cb(VALUE key, VALUE value, VALUE x) {
-    if (Qtrue == rb_obj_tainted(value)) {
-	rb_obj_untaint(value);
-    }
+umark_hash_cb(VALUE key, VALUE value, VALUE x) {
+    unmark((PInfo)x, value);
+
     return ST_CONTINUE;
 }
 
 static void
-end_element_core(PInfo pi, const char *ename, bool check_taint) {
+end_element_core(PInfo pi, const char *ename, bool check_marked) {
     Helper		e = helper_stack_pop(&pi->helpers);
     Helper		parent = helper_stack_peek(&pi->helpers);
     volatile VALUE	pobj = parent->obj;
@@ -161,8 +199,8 @@ end_element_core(PInfo pi, const char *ename, bool check_taint) {
     if (Qundef == found) {
 	rb_hash_aset(pobj, key, e->obj);
     } else if (RUBY_T_ARRAY == rb_type(found)) {
-	if (check_taint && Qtrue == rb_obj_tainted(found)) {
-	    rb_obj_untaint(found);
+	if (check_marked && marked(pi, found)) {
+	    unmark(pi, found);
 	    a = rb_ary_new();
 	    rb_ary_push(a, found);
 	    rb_ary_push(a, e->obj);
@@ -171,16 +209,16 @@ end_element_core(PInfo pi, const char *ename, bool check_taint) {
 	    rb_ary_push(found, e->obj);
 	}
     } else { // something there other than an array
-	if (check_taint && Qtrue == rb_obj_tainted(e->obj)) {
-	    rb_obj_untaint(e->obj);
+	if (check_marked && marked(pi, e->obj)) {
+	    unmark(pi, e->obj);
 	}
 	a = rb_ary_new();
 	rb_ary_push(a, found);
 	rb_ary_push(a, e->obj);
 	rb_hash_aset(pobj, key, a);
     }
-    if (check_taint && RUBY_T_HASH == rb_type(e->obj)) {
-	rb_hash_foreach(e->obj, untaint_hash_cb, Qnil);
+    if (check_marked && NULL != pi->marked && RUBY_T_HASH == rb_type(e->obj)) {
+	rb_hash_foreach(e->obj, umark_hash_cb, (VALUE)pi);
     }
 }
 
@@ -196,9 +234,7 @@ end_element_no_attrs(PInfo pi, const char *ename) {
 
 static void
 finish(PInfo pi) {
-    if (Qnil != pi->obj && RUBY_T_HASH == rb_type(pi->obj)) {
-	rb_hash_foreach(pi->obj, untaint_hash_cb, Qnil);
-    }
+    xfree(pi->marked);
 }
 
 struct _parseCallbacks   _ox_hash_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) {
@@ -255,7 +253,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 +262,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 +359,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 +375,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 +407,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 +480,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 +524,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 +648,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))) {
@@ -750,23 +723,17 @@ end_element(PInfo pi, const char *ename) {
 		}
 		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 +744,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:
 		{