ox-bundlecachetest 2.14.23

data/ext/ox/ox.c

@@ -0,0 +1,1649 @@
+/* ox.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "ox.h"
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "intern.h"
+#include "ruby.h"
+#include "sax.h"
+
+/* maximum to allocate on the stack, arbitrary limit */
+#define SMALL_XML 4096
+#define WITH_CACHE_TESTS 0
+
+typedef struct _yesNoOpt {
+    VALUE sym;
+    char *attr;
+} *YesNoOpt;
+
+void Init_ox();
+
+VALUE Ox = Qnil;
+
+ID ox_abort_id;
+ID ox_at_column_id;
+ID ox_at_content_id;
+ID ox_at_id;
+ID ox_at_line_id;
+ID ox_at_pos_id;
+ID ox_at_value_id;
+ID ox_attr_id;
+ID ox_attr_value_id;
+ID ox_attributes_id;
+ID ox_attrs_done_id;
+ID ox_beg_id;
+ID ox_bigdecimal_id;
+ID ox_call_id;
+ID ox_cdata_id;
+ID ox_comment_id;
+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;
+ID ox_fileno_id;
+ID ox_force_encoding_id;
+ID ox_inspect_id;
+ID ox_instruct_id;
+ID ox_jd_id;
+ID ox_keys_id;
+ID ox_local_id;
+ID ox_mesg_id;
+ID ox_message_id;
+ID ox_new_id;
+ID ox_nodes_id;
+ID ox_num_id;
+ID ox_parse_id;
+ID ox_pos_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_value_id;
+
+VALUE ox_encoding_sym;
+VALUE ox_version_sym;
+VALUE ox_standalone_sym;
+VALUE ox_indent_sym;
+VALUE ox_size_sym;
+
+VALUE ox_empty_string;
+VALUE ox_zero_fixnum;
+VALUE ox_sym_bank;  // Array
+
+VALUE ox_arg_error_class;
+VALUE ox_bag_clas;
+VALUE ox_cdata_clas;
+VALUE ox_comment_clas;
+VALUE ox_raw_clas;
+VALUE ox_date_class;
+VALUE ox_doctype_clas;
+VALUE ox_document_clas;
+VALUE ox_element_clas;
+VALUE ox_instruct_clas;
+VALUE ox_parse_error_class;
+VALUE ox_stringio_class;
+VALUE ox_struct_class;
+VALUE ox_syntax_error_class;
+VALUE ox_time_class;
+
+SlotCache ox_class_cache = 0;
+
+static VALUE abort_sym;
+static VALUE active_sym;
+static VALUE attr_key_mod_sym;
+static VALUE auto_define_sym;
+static VALUE auto_sym;
+static VALUE block_sym;
+static VALUE circular_sym;
+static VALUE convert_special_sym;
+static VALUE effort_sym;
+static VALUE generic_sym;
+static VALUE hash_no_attrs_sym;
+static VALUE hash_sym;
+static VALUE inactive_sym;
+static VALUE invalid_replace_sym;
+static VALUE limited_sym;
+static VALUE margin_sym;
+static VALUE mode_sym;
+static VALUE nest_ok_sym;
+static VALUE no_empty_sym;
+static VALUE object_sym;
+static VALUE off_sym;
+static VALUE opt_format_sym;
+static VALUE optimized_sym;
+static VALUE overlay_sym;
+static VALUE skip_none_sym;
+static VALUE skip_off_sym;
+static VALUE skip_return_sym;
+static VALUE skip_sym;
+static VALUE skip_white_sym;
+static VALUE smart_sym;
+static VALUE strict_sym;
+static VALUE strip_namespace_sym;
+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;
+static VALUE xsd_date_sym;
+static VALUE element_key_mod_sym;
+
+static ID encoding_id;
+static ID has_key_id;
+
+rb_encoding *ox_utf8_encoding = 0;
+
+struct _options ox_default_options = {
+    {'\0'},        // encoding
+    {'\0'},        // margin
+    2,             // indent
+    0,             // trace
+    0,             // margin_len
+    No,            // with_dtd
+    No,            // with_xml
+    No,            // with_instruct
+    No,            // circular
+    No,            // xsd_date
+    NoMode,        // mode
+    StrictEffort,  // effort
+    Yes,           // sym_keys
+    SpcSkip,       // skip
+    No,            // smart
+    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;
+    0              // rb_enc
+};
+
+extern ParseCallbacks ox_obj_callbacks;
+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);
+
+static char *defuse_bom(char *xml, Options options) {
+    switch ((uint8_t)*xml) {
+    case 0xEF:  // UTF-8
+        if (0xBB == (uint8_t)xml[1] && 0xBF == (uint8_t)xml[2]) {
+            options->rb_enc = ox_utf8_encoding;
+            xml += 3;
+        } else {
+            rb_raise(ox_parse_error_class, "Invalid BOM in XML string.\n");
+        }
+        break;
+#if 0
+    case 0xFE: // UTF-16BE
+	if (0xFF == (uint8_t)xml[1]) {
+	    options->rb_enc = ox_utf16be_encoding;
+	    xml += 2;
+	} else {
+	    rb_raise(ox_parse_error_class, "Invalid BOM in XML string.\n");
+	}
+	break;
+    case 0xFF: // UTF-16LE or UTF-32LE
+	if (0xFE == (uint8_t)xml[1]) {
+	    if (0x00 == (uint8_t)xml[2] && 0x00 == (uint8_t)xml[3]) {
+		options->rb_enc = ox_utf32le_encoding;
+		xml += 4;
+	    } else {
+		options->rb_enc = ox_utf16le_encoding;
+		xml += 2;
+	    }
+	} else {
+	    rb_raise(ox_parse_error_class, "Invalid BOM in XML string.\n");
+	}
+	break;
+    case 0x00: // UTF-32BE
+	if (0x00 == (uint8_t)xml[1] && 0xFE == (uint8_t)xml[2] && 0xFF == (uint8_t)xml[3]) {
+	    options->rb_enc = ox_utf32be_encoding;
+	    xml += 4;
+	} else {
+	    rb_raise(ox_parse_error_class, "Invalid BOM in XML string.\n");
+	}
+	break;
+#endif
+    default:
+        // Let it fail if there is a BOM that is not UTF-8. Other BOM options
+        // are not ASCII compatible.
+        break;
+    }
+    return xml;
+}
+
+static VALUE hints_to_overlay(Hints hints) {
+    volatile VALUE overlay = rb_hash_new();
+    Hint           h;
+    int            i;
+    VALUE          ov;
+
+    for (i = hints->size, h = hints->hints; 0 < i; i--, h++) {
+        switch (h->overlay) {
+        case InactiveOverlay: ov = inactive_sym; break;
+        case BlockOverlay: ov = block_sym; break;
+        case OffOverlay: ov = off_sym; break;
+        case AbortOverlay: ov = abort_sym; break;
+        case NestOverlay: ov = nest_ok_sym; break;
+        case ActiveOverlay:
+        default: ov = active_sym; break;
+        }
+        rb_hash_aset(overlay, rb_str_new2(h->name), ov);
+    }
+    return overlay;
+}
+
+/* call-seq: default_options() => Hash
+ *
+ * Returns the default load and dump options as a Hash. The options are
+ * - _:margin_ [String] left margin to inset when dumping
+ * - _:indent_ [Fixnum] number of spaces to indent each element in an XML document
+ * - _:trace_ [Fixnum] trace level where 0 is silent
+ * - _:encoding_ [String] character encoding for the XML file
+ * - _:with_dtd_ [true|false|nil] include DTD in the dump
+ * - _:with_instruct_ [true|false|nil] include instructions in the dump
+ * - _:with_xml_ [true|false|nil] include XML prolog in the dump
+ * - _:circular_ [true|false|nil] support circular references while dumping
+ * - _:xsd_date_ [true|false|nil] use XSD date format instead of decimal format
+ * - _:mode_ [:object|:generic|:limited|:hash|:hash_no_attrs|nil] load method to use for XML
+ * - _:effort_ [:strict|:tolerant|:auto_define] set the tolerance level for loading
+ * - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings
+ * - _:element_key_mod_ [Proc|nil] converts element keys on parse if not nil
+ * - _:attr_key_mod_ [Proc|nil] converts attribute keys on parse if not nil
+ * - _:skip_ [:skip_none|:skip_return|:skip_white|:skip_off] determines how to handle white space in text
+ * - _:smart_ [true|false|nil] flag indicating the SAX parser uses hints if available (use with html)
+ * - _:convert_special_ [true|false|nil] flag indicating special characters like &lt; 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
+ *   - _:nest_ok_ - active but the nesting check is ignored
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ *
+ * *return* [Hash] all current option settings.
+ *
+ * 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 get_def_opts(VALUE self) {
+    VALUE opts = rb_hash_new();
+    int   elen = (int)strlen(ox_default_options.encoding);
+
+    rb_hash_aset(opts, ox_encoding_sym, (0 == elen) ? Qnil : rb_str_new(ox_default_options.encoding, elen));
+    rb_hash_aset(opts, margin_sym, rb_str_new(ox_default_options.margin, ox_default_options.margin_len));
+    rb_hash_aset(opts, ox_indent_sym, INT2FIX(ox_default_options.indent));
+    rb_hash_aset(opts, trace_sym, INT2FIX(ox_default_options.trace));
+    rb_hash_aset(opts,
+                 with_dtd_sym,
+                 (Yes == ox_default_options.with_dtd) ? Qtrue : ((No == ox_default_options.with_dtd) ? Qfalse : Qnil));
+    rb_hash_aset(opts,
+                 with_xml_sym,
+                 (Yes == ox_default_options.with_xml) ? Qtrue : ((No == ox_default_options.with_xml) ? Qfalse : Qnil));
+    rb_hash_aset(
+        opts,
+        with_instruct_sym,
+        (Yes == ox_default_options.with_instruct) ? Qtrue : ((No == ox_default_options.with_instruct) ? Qfalse : Qnil));
+    rb_hash_aset(opts,
+                 circular_sym,
+                 (Yes == ox_default_options.circular) ? Qtrue : ((No == ox_default_options.circular) ? Qfalse : Qnil));
+    rb_hash_aset(opts,
+                 xsd_date_sym,
+                 (Yes == ox_default_options.xsd_date) ? Qtrue : ((No == ox_default_options.xsd_date) ? Qfalse : Qnil));
+    rb_hash_aset(opts,
+                 symbolize_keys_sym,
+                 (Yes == ox_default_options.sym_keys) ? Qtrue : ((No == ox_default_options.sym_keys) ? Qfalse : Qnil));
+    rb_hash_aset(opts, attr_key_mod_sym, ox_default_options.attr_key_mod);
+    rb_hash_aset(opts, element_key_mod_sym, ox_default_options.element_key_mod);
+    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;
+    case LimMode: rb_hash_aset(opts, mode_sym, limited_sym); break;
+    case HashMode: rb_hash_aset(opts, mode_sym, hash_sym); break;
+    case HashNoAttrMode: rb_hash_aset(opts, mode_sym, hash_no_attrs_sym); break;
+    case NoMode:
+    default: rb_hash_aset(opts, mode_sym, Qnil); break;
+    }
+    switch (ox_default_options.effort) {
+    case StrictEffort: rb_hash_aset(opts, effort_sym, strict_sym); break;
+    case TolerantEffort: rb_hash_aset(opts, effort_sym, tolerant_sym); break;
+    case AutoEffort: rb_hash_aset(opts, effort_sym, auto_define_sym); break;
+    case NoEffort:
+    default: rb_hash_aset(opts, effort_sym, Qnil); break;
+    }
+    switch (ox_default_options.skip) {
+    case OffSkip: rb_hash_aset(opts, skip_sym, skip_off_sym); break;
+    case NoSkip: rb_hash_aset(opts, skip_sym, skip_none_sym); break;
+    case CrSkip: rb_hash_aset(opts, skip_sym, skip_return_sym); break;
+    case SpcSkip: rb_hash_aset(opts, skip_sym, skip_white_sym); break;
+    default: rb_hash_aset(opts, skip_sym, Qnil); break;
+    }
+    if (Yes == ox_default_options.allow_invalid) {
+        rb_hash_aset(opts, invalid_replace_sym, Qnil);
+    } else {
+        rb_hash_aset(opts,
+                     invalid_replace_sym,
+                     rb_str_new(ox_default_options.inv_repl + 1, (int)*ox_default_options.inv_repl));
+    }
+    if ('\0' == *ox_default_options.strip_ns) {
+        rb_hash_aset(opts, strip_namespace_sym, Qfalse);
+    } else if ('*' == *ox_default_options.strip_ns && '\0' == ox_default_options.strip_ns[1]) {
+        rb_hash_aset(opts, strip_namespace_sym, Qtrue);
+    } else {
+        rb_hash_aset(opts,
+                     strip_namespace_sym,
+                     rb_str_new(ox_default_options.strip_ns, strlen(ox_default_options.strip_ns)));
+    }
+    if (NULL == ox_default_options.html_hints) {
+        // rb_hash_aset(opts, overlay_sym, hints_to_overlay(ox_hints_html()));
+        rb_hash_aset(opts, overlay_sym, Qnil);
+    } else {
+        rb_hash_aset(opts, overlay_sym, hints_to_overlay(ox_default_options.html_hints));
+    }
+    return opts;
+}
+
+static int set_overlay(VALUE key, VALUE value, VALUE ctx) {
+    Hints hints = (Hints)ctx;
+    Hint  hint;
+
+    if (NULL != (hint = ox_hint_find(hints, StringValuePtr(key)))) {
+        if (active_sym == value) {
+            hint->overlay = ActiveOverlay;
+        } else if (inactive_sym == value) {
+            hint->overlay = InactiveOverlay;
+        } else if (block_sym == value) {
+            hint->overlay = BlockOverlay;
+        } else if (nest_ok_sym == value) {
+            hint->overlay = NestOverlay;
+        } else if (off_sym == value) {
+            hint->overlay = OffOverlay;
+        } else if (abort_sym == value) {
+            hint->overlay = AbortOverlay;
+        }
+    }
+    return ST_CONTINUE;
+}
+
+/* call-seq: sax_html_overlay() => Hash
+ *
+ * Returns an overlay hash that can be modified and used as an overlay in the
+ * default options or in the sax_html() function call. Values for the keys are:
+ *   - _:active_ - make the normal callback for the element
+ *   - _:nest_ok_ - active but ignore nest check
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ *
+ * *return* [Hash] default SAX HTML settings
+ */
+static VALUE sax_html_overlay(VALUE self) {
+    return hints_to_overlay(ox_hints_html());
+}
+
+/* call-seq: default_options=(opts)
+ *
+ * Sets the default options for load and dump.
+ * - +opts+ [Hash] opts options to change
+ *   - _:margin_ [String] left margin to inset when dumping
+ *   - _:indent_ [Fixnum] number of spaces to indent each element in an XML document
+ *   - _:trace_ [Fixnum] trace level where 0 is silent
+ *   - _:encoding_ [String] character encoding for the XML file
+ *   - _:with_dtd_ [true|false|nil] include DTD in the dump
+ *   - _:with_instruct_ [true|false|nil] include instructions in the dump
+ *   - _:with_xml_ [true|false|nil] include XML prolog in the dump
+ *   - _:circular_ [true|false|nil] support circular references while dumping
+ *   - _:xsd_date_ [true|false|nil] use XSD date format instead of decimal format
+ *   - _:mode_ [:object|:generic|:limited|:hash|:hash_no_attrs|nil] load method to use for XML
+ *   - _:effort_ [:strict|:tolerant|:auto_define] set the tolerance level for loading
+ *   - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings
+ *   - _:element_key_mod_ [Proc|nil] converts element keys on parse if not nil
+ *   - _:attr_key_mod_ [Proc|nil] converts attribute keys on parse if not nil
+ *   - _:skip_ [:skip_none|:skip_return|:skip_white|:skip_off] determines how to handle white space in text
+ *   - _: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
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ *
+ * *return* [nil]
+ */
+static VALUE set_def_opts(VALUE self, VALUE opts) {
+    struct _yesNoOpt ynos[] = {{with_xml_sym, &ox_default_options.with_xml},
+                               {with_dtd_sym, &ox_default_options.with_dtd},
+                               {with_instruct_sym, &ox_default_options.with_instruct},
+                               {xsd_date_sym, &ox_default_options.xsd_date},
+                               {circular_sym, &ox_default_options.circular},
+                               {symbolize_keys_sym, &ox_default_options.sym_keys},
+                               {smart_sym, &ox_default_options.smart},
+                               {Qnil, 0}};
+    YesNoOpt         o;
+    VALUE            v;
+
+    Check_Type(opts, T_HASH);
+
+    v = rb_hash_aref(opts, ox_encoding_sym);
+    if (Qnil == v) {
+        *ox_default_options.encoding = '\0';
+    } else {
+        Check_Type(v, T_STRING);
+        strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
+        ox_default_options.rb_enc = rb_enc_find(ox_default_options.encoding);
+    }
+
+    v = rb_hash_aref(opts, ox_indent_sym);
+    if (Qnil != v) {
+        Check_Type(v, T_FIXNUM);
+        ox_default_options.indent = FIX2INT(v);
+    }
+
+    v = rb_hash_aref(opts, trace_sym);
+    if (Qnil != v) {
+        Check_Type(v, T_FIXNUM);
+        ox_default_options.trace = FIX2INT(v);
+    }
+
+    v = rb_hash_aref(opts, mode_sym);
+    if (Qnil == v) {
+        ox_default_options.mode = NoMode;
+    } else if (object_sym == v) {
+        ox_default_options.mode = ObjMode;
+    } else if (generic_sym == v) {
+        ox_default_options.mode = GenMode;
+    } else if (limited_sym == v) {
+        ox_default_options.mode = LimMode;
+    } else if (hash_sym == v) {
+        ox_default_options.mode = HashMode;
+    } else if (hash_no_attrs_sym == v) {
+        ox_default_options.mode = HashNoAttrMode;
+    } else {
+        rb_raise(ox_parse_error_class, ":mode must be :object, :generic, :limited, :hash, :hash_no_attrs, or nil.\n");
+    }
+
+    v = rb_hash_aref(opts, effort_sym);
+    if (Qnil == v) {
+        ox_default_options.effort = NoEffort;
+    } else if (strict_sym == v) {
+        ox_default_options.effort = StrictEffort;
+    } else if (tolerant_sym == v) {
+        ox_default_options.effort = TolerantEffort;
+    } else if (auto_define_sym == v) {
+        ox_default_options.effort = AutoEffort;
+    } else {
+        rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, :auto_define, or nil.\n");
+    }
+
+    v = rb_hash_aref(opts, skip_sym);
+    if (Qnil == v) {
+        ox_default_options.skip = NoSkip;
+    } else if (skip_off_sym == v) {
+        ox_default_options.skip = OffSkip;
+    } else if (skip_none_sym == v) {
+        ox_default_options.skip = NoSkip;
+    } else if (skip_return_sym == v) {
+        ox_default_options.skip = CrSkip;
+    } else if (skip_white_sym == v) {
+        ox_default_options.skip = SpcSkip;
+    } else {
+        rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, :skip_off, or nil.\n");
+    }
+
+    v = rb_hash_lookup(opts, convert_special_sym);
+    if (Qnil == v) {
+        // no change
+    } else if (Qtrue == v) {
+        ox_default_options.convert_special = 1;
+    } else if (Qfalse == v) {
+        ox_default_options.convert_special = 0;
+    } else {
+        rb_raise(ox_parse_error_class, ":convert_special must be true or false.\n");
+    }
+
+    v = rb_hash_lookup(opts, no_empty_sym);
+    if (Qnil == v) {
+        // no change
+    } else if (Qtrue == v) {
+        ox_default_options.no_empty = 1;
+    } else if (Qfalse == v) {
+        ox_default_options.no_empty = 0;
+    } else {
+        rb_raise(ox_parse_error_class, ":no_empty must be true or false.\n");
+    }
+
+    v = rb_hash_aref(opts, invalid_replace_sym);
+    if (Qnil == v) {
+        ox_default_options.allow_invalid = Yes;
+    } else {
+        long slen;
+
+        Check_Type(v, T_STRING);
+        slen = RSTRING_LEN(v);
+        if (sizeof(ox_default_options.inv_repl) - 2 < (size_t)slen) {
+            rb_raise(ox_parse_error_class,
+                     ":invalid_replace can be no longer than %d characters.",
+                     (int)sizeof(ox_default_options.inv_repl) - 2);
+        }
+        strncpy(ox_default_options.inv_repl + 1, StringValuePtr(v), sizeof(ox_default_options.inv_repl) - 1);
+        ox_default_options.inv_repl[sizeof(ox_default_options.inv_repl) - 1] = '\0';
+        *ox_default_options.inv_repl                                         = (char)slen;
+        ox_default_options.allow_invalid                                     = No;
+    }
+
+    v = rb_hash_aref(opts, strip_namespace_sym);
+    if (Qfalse == v) {
+        *ox_default_options.strip_ns = '\0';
+    } else if (Qtrue == v) {
+        *ox_default_options.strip_ns   = '*';
+        ox_default_options.strip_ns[1] = '\0';
+    } else if (Qnil != v) {
+        long slen;
+
+        Check_Type(v, T_STRING);
+        slen = RSTRING_LEN(v);
+        if (sizeof(ox_default_options.strip_ns) - 1 < (size_t)slen) {
+            rb_raise(ox_parse_error_class,
+                     ":strip_namespace can be no longer than %d characters.",
+                     (int)sizeof(ox_default_options.strip_ns) - 1);
+        }
+        strncpy(ox_default_options.strip_ns, StringValuePtr(v), sizeof(ox_default_options.strip_ns) - 1);
+        ox_default_options.strip_ns[sizeof(ox_default_options.strip_ns) - 1] = '\0';
+    }
+
+    v = rb_hash_aref(opts, margin_sym);
+    if (Qnil != v) {
+        long slen;
+
+        Check_Type(v, T_STRING);
+        slen = RSTRING_LEN(v);
+        if (sizeof(ox_default_options.margin) - 1 < (size_t)slen) {
+            rb_raise(ox_parse_error_class,
+                     ":margin can be no longer than %d characters.",
+                     (int)sizeof(ox_default_options.margin) - 1);
+        }
+        strncpy(ox_default_options.margin, StringValuePtr(v), sizeof(ox_default_options.margin) - 1);
+        ox_default_options.margin[sizeof(ox_default_options.margin) - 1] = '\0';
+        ox_default_options.margin_len                                    = strlen(ox_default_options.margin);
+    }
+
+    for (o = ynos; 0 != o->attr; o++) {
+        v = rb_hash_lookup(opts, o->sym);
+        if (Qnil == v) {
+            *o->attr = NotSet;
+        } else if (Qtrue == v) {
+            *o->attr = Yes;
+        } else if (Qfalse == v) {
+            *o->attr = No;
+        } else {
+            rb_raise(ox_parse_error_class, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
+        }
+    }
+    v = rb_hash_aref(opts, overlay_sym);
+    if (Qnil == v) {
+        ox_hints_destroy(ox_default_options.html_hints);
+        ox_default_options.html_hints = NULL;
+    } else {
+        int cnt;
+
+        Check_Type(v, T_HASH);
+        cnt = (int)RHASH_SIZE(v);
+        if (0 == cnt) {
+            ox_hints_destroy(ox_default_options.html_hints);
+            ox_default_options.html_hints = NULL;
+        } else {
+            ox_hints_destroy(ox_default_options.html_hints);
+            ox_default_options.html_hints = ox_hints_dup(ox_hints_html());
+            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);
+
+    return Qnil;
+}
+
+/* call-seq: parse_obj(xml) => Object
+ *
+ * Parses an XML document String that is in the object format and returns an
+ * Object of the type represented by the XML. This function expects an
+ * optimized XML formated String. For other formats use the more generic
+ * Ox.load() method.  Raises an exception if the XML is malformed or the
+ * classes specified in the file are not valid.
+ * - +xml+ [String] XML String in optimized Object format.
+ * *return* [Object] deserialized Object.
+ */
+static VALUE to_obj(VALUE self, VALUE ruby_xml) {
+    char           *xml, *x;
+    size_t          len;
+    VALUE           obj;
+    struct _options options = ox_default_options;
+    struct _err     err;
+
+    err_init(&err);
+    Check_Type(ruby_xml, T_STRING);
+    /* the xml string gets modified so make a copy of it */
+    len = RSTRING_LEN(ruby_xml) + 1;
+    x   = defuse_bom(StringValuePtr(ruby_xml), &options);
+    if (SMALL_XML < len) {
+        xml = ALLOC_N(char, len);
+    } else {
+        xml = ALLOCA_N(char, len);
+    }
+    memcpy(xml, x, len);
+    rb_gc_disable();
+    obj = ox_parse(xml, len - 1, ox_obj_callbacks, 0, &options, &err);
+    if (SMALL_XML < len) {
+        xfree(xml);
+    }
+    RB_GC_GUARD(obj);
+    rb_gc_enable();
+    if (err_has(&err)) {
+        ox_err_raise(&err);
+    }
+    return obj;
+}
+
+/* call-seq: parse(xml) => Ox::Document or Ox::Element
+ *
+ * Parses and XML document String into an Ox::Document or Ox::Element.
+ * - +xml+ [String] xml XML String
+ * *return* [Ox::Document or Ox::Element] parsed XML document.
+ *
+ * _raise_ [Exception] if the XML is malformed.
+ */
+static VALUE to_gen(VALUE self, VALUE ruby_xml) {
+    char           *xml, *x;
+    size_t          len;
+    VALUE           obj;
+    struct _options options = ox_default_options;
+    struct _err     err;
+
+    err_init(&err);
+    Check_Type(ruby_xml, T_STRING);
+    /* the xml string gets modified so make a copy of it */
+    len = RSTRING_LEN(ruby_xml) + 1;
+    x   = defuse_bom(StringValuePtr(ruby_xml), &options);
+    if (SMALL_XML < len) {
+        xml = ALLOC_N(char, len);
+    } else {
+        xml = ALLOCA_N(char, len);
+    }
+    memcpy(xml, x, len);
+    obj = ox_parse(xml, len - 1, ox_gen_callbacks, 0, &options, &err);
+    if (SMALL_XML < len) {
+        xfree(xml);
+    }
+    if (err_has(&err)) {
+        ox_err_raise(&err);
+    }
+    return obj;
+}
+
+static int load_options_cb(VALUE k, VALUE v, VALUE opts) {
+    Options copts = (Options)opts;
+
+    if (mode_sym == k) {
+        if (object_sym == v) {
+            copts->mode = ObjMode;
+        } else if (optimized_sym == v) {
+            copts->mode = ObjMode;
+        } else if (generic_sym == v) {
+            copts->mode = GenMode;
+        } else if (limited_sym == v) {
+            copts->mode = LimMode;
+        } else if (hash_sym == v) {
+            copts->mode = HashMode;
+        } else if (hash_no_attrs_sym == v) {
+            copts->mode = HashNoAttrMode;
+        } else {
+            rb_raise(ox_parse_error_class, ":mode must be :generic, :object, :limited, :hash, :hash_no_attrs.\n");
+        }
+    } else if (effort_sym == k) {
+        if (auto_define_sym == v) {
+            copts->effort = AutoEffort;
+        } else if (tolerant_sym == v) {
+            copts->effort = TolerantEffort;
+        } else if (strict_sym == v) {
+            copts->effort = StrictEffort;
+        } else {
+            rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
+        }
+    } else if (skip_sym == k) {
+        if (skip_none_sym == v) {
+            copts->skip = NoSkip;
+        } else if (skip_off_sym == v) {
+            copts->skip = OffSkip;
+        } else if (skip_return_sym == v) {
+            copts->skip = CrSkip;
+        } else if (skip_white_sym == v) {
+            copts->skip = SpcSkip;
+        } else {
+            rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, or :skip_off.\n");
+        }
+    } else if (trace_sym == k) {
+        Check_Type(v, T_FIXNUM);
+        copts->trace = FIX2INT(v);
+    } else if (symbolize_keys_sym == k) {
+        copts->sym_keys = (Qfalse == v) ? No : Yes;
+    } else if (element_key_mod_sym == k) {
+        copts->element_key_mod = v;
+    } else if (attr_key_mod_sym == k) {
+        copts->attr_key_mod = v;
+    } else if (convert_special_sym == k) {
+        copts->convert_special = (Qfalse != v);
+    } else if (no_empty_sym == k) {
+        copts->no_empty = (Qfalse != v);
+    } else if (invalid_replace_sym == k) {
+        if (Qnil == v) {
+            copts->allow_invalid = Yes;
+        } else {
+            long slen;
+
+            Check_Type(v, T_STRING);
+            slen = RSTRING_LEN(v);
+            if (sizeof(copts->inv_repl) - 2 < (size_t)slen) {
+                rb_raise(ox_parse_error_class,
+                         ":invalid_replace can be no longer than %d characters.",
+                         (int)sizeof(copts->inv_repl) - 2);
+            }
+            strncpy(copts->inv_repl + 1, StringValuePtr(v), sizeof(copts->inv_repl) - 1);
+            copts->inv_repl[sizeof(copts->inv_repl) - 1] = '\0';
+            *copts->inv_repl                             = (char)slen;
+            copts->allow_invalid                         = No;
+        }
+    } else if (strip_namespace_sym == k) {
+        if (Qfalse == v) {
+            *copts->strip_ns = '\0';
+        } else if (Qtrue == v) {
+            *copts->strip_ns   = '*';
+            copts->strip_ns[1] = '\0';
+        } else if (Qnil != v) {
+            long slen;
+
+            Check_Type(v, T_STRING);
+            slen = RSTRING_LEN(v);
+            if (sizeof(copts->strip_ns) - 1 < (size_t)slen) {
+                rb_raise(ox_parse_error_class,
+                         ":strip_namespace can be no longer than %d characters.",
+                         (int)sizeof(copts->strip_ns) - 1);
+            }
+            strncpy(copts->strip_ns, StringValuePtr(v), sizeof(copts->strip_ns) - 1);
+            copts->strip_ns[sizeof(copts->strip_ns) - 1] = '\0';
+        }
+    } else if (margin_sym == k) {
+        long slen;
+
+        Check_Type(v, T_STRING);
+        slen = RSTRING_LEN(v);
+        if (sizeof(copts->margin) - 1 < (size_t)slen) {
+            rb_raise(ox_parse_error_class,
+                     ":margin can be no longer than %d characters.",
+                     (int)sizeof(copts->margin) - 1);
+        }
+        strncpy(copts->margin, StringValuePtr(v), sizeof(copts->margin) - 1);
+        copts->margin[sizeof(copts->margin) - 1] = '\0';
+        copts->margin_len                        = strlen(copts->margin);
+    } else if (with_cdata_sym == k) {
+        copts->with_cdata = (Qtrue == v);
+    }
+
+    return ST_CONTINUE;
+}
+
+static VALUE load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
+    VALUE           obj;
+    struct _options options = ox_default_options;
+
+    if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
+        rb_hash_foreach(*argv, load_options_cb, (VALUE)&options);
+    }
+    if ('\0' == *options.encoding) {
+        if (Qnil != encoding) {
+            options.rb_enc = rb_enc_from_index(rb_enc_get_index(encoding));
+        } else {
+            options.rb_enc = 0;
+        }
+    } else if (0 == options.rb_enc) {
+        options.rb_enc = rb_enc_find(options.encoding);
+    }
+    xml = defuse_bom(xml, &options);
+    switch (options.mode) {
+    case ObjMode:
+        rb_gc_disable();
+        obj = ox_parse(xml, len, ox_obj_callbacks, 0, &options, err);
+        RB_GC_GUARD(obj);
+        rb_gc_enable();
+        break;
+    case GenMode: obj = ox_parse(xml, len, ox_gen_callbacks, 0, &options, err); break;
+    case LimMode: obj = ox_parse(xml, len, ox_limited_callbacks, 0, &options, err); break;
+    case HashMode:
+        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:
+        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); break;
+    default: obj = ox_parse(xml, len, ox_gen_callbacks, 0, &options, err); break;
+    }
+    return obj;
+}
+
+/* call-seq: load(xml, options) => Ox::Document or Ox::Element or Object
+ *
+ * Parses and XML document String into an Ox::Document, or Ox::Element, or
+ * Object depending on the options.  Raises an exception if the XML is malformed
+ * or the classes specified are not valid. If a block is given it will be called
+ * on the completion of each complete top level entity with that entity as it's
+ * only argument.
+ *
+ * - +xml+ [String] XML String
+ * - +options+ [Hash] load options
+ *   - *:mode* [:object|:generic|:limited] format expected
+ *     - _:object_ - object format
+ *     - _:generic_ - read as a generic XML file
+ *     - _:limited_ - read as a generic XML file but with callbacks on text and elements events only
+ *     - _:hash_ - read and convert to a Hash and core class objects only
+ *     - _:hash_no_attrs_ - read and convert to a Hash and core class objects only without capturing attributes
+ *   - *:effort* [:strict|:tolerant|:auto_define] effort to use when an undefined class is encountered, default: :strict
+ *     - _:strict_ - raise an NameError for missing classes and modules
+ *     - _:tolerant_ - return nil for missing classes and modules
+ *     - _:auto_define_ - auto define missing classes and modules
+ *   - *:trace* [Fixnum] trace level as a Fixnum, default: 0 (silent)
+ *   - *: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) {
+    char       *xml;
+    size_t      len;
+    VALUE       obj;
+    VALUE       encoding;
+    struct _err err;
+
+    err_init(&err);
+    Check_Type(*argv, T_STRING);
+    /* the xml string gets modified so make a copy of it */
+    len = RSTRING_LEN(*argv) + 1;
+    if (SMALL_XML < len) {
+        xml = ALLOC_N(char, len);
+    } else {
+        xml = ALLOCA_N(char, len);
+    }
+    encoding = rb_obj_encoding(*argv);
+    memcpy(xml, StringValuePtr(*argv), len);
+    xml[len - 1] = '\0';
+    obj          = load(xml, len - 1, argc - 1, argv + 1, self, encoding, &err);
+    if (SMALL_XML < len) {
+        xfree(xml);
+    }
+    if (err_has(&err)) {
+        ox_err_raise(&err);
+    }
+    return obj;
+}
+
+/* call-seq: load_file(file_path, options) => Ox::Document or Ox::Element or Object
+ *
+ * Parses and XML document from a file into an Ox::Document, or Ox::Element,
+ * or Object depending on the options.	Raises an exception if the XML is
+ * malformed or the classes specified are not valid.
+ * - +file_path+ [String] file path to read the XML document from
+ * - +options+ [Hash] load options
+ *   - *:mode* [:object|:generic|:limited] format expected
+ *     - _:object_ - object format
+ *     - _:generic_ - read as a generic XML file
+ *     - _:limited_ - read as a generic XML file but with callbacks on text and elements events only
+ *     - _:hash_ - read and convert to a Hash and core class objects only
+ *     - _:hash_no_attrs_ - read and convert to a Hash and core class objects only without capturing attributes
+ *   - *:effort* [:strict|:tolerant|:auto_define] effort to use when an undefined class is encountered, default: :strict
+ *     - _:strict_ - raise an NameError for missing classes and modules
+ *     - _:tolerant_ - return nil for missing classes and modules
+ *     - _:auto_define_ - auto define missing classes and modules
+ *   - *:trace* [Fixnum] trace level as a Fixnum, default: 0 (silent)
+ *   - *: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.
+ */
+static VALUE load_file(int argc, VALUE *argv, VALUE self) {
+    char       *path;
+    char       *xml;
+    FILE       *f;
+    off_t       len;
+    VALUE       obj;
+    struct _err err;
+
+    err_init(&err);
+    Check_Type(*argv, T_STRING);
+    path = StringValuePtr(*argv);
+    if (0 == (f = fopen(path, "r"))) {
+        rb_raise(rb_eIOError, "%s\n", strerror(errno));
+    }
+    fseek(f, 0, SEEK_END);
+    len = ftello(f);
+    if (SMALL_XML < len) {
+        xml = ALLOC_N(char, len + 1);
+    } else {
+        xml = ALLOCA_N(char, len + 1);
+    }
+    fseek(f, 0, SEEK_SET);
+    if ((size_t)len != fread(xml, 1, len, f)) {
+        ox_err_set(&err, rb_eLoadError, "Failed to read %ld bytes from %s.\n", (long)len, path);
+        obj = Qnil;
+    } else {
+        xml[len] = '\0';
+        obj      = load(xml, len, argc - 1, argv + 1, self, Qnil, &err);
+    }
+    fclose(f);
+    if (SMALL_XML < len) {
+        xfree(xml);
+    }
+    if (err_has(&err)) {
+        ox_err_raise(&err);
+    }
+    return obj;
+}
+
+/* call-seq: sax_parse(handler, io, options)
+ *
+ * Parses an IO stream or file containing an XML document. Raises an exception
+ * if the XML is malformed or the classes specified are not valid.
+ * - +handler+ [Ox::Sax] SAX (responds to OX::Sax methods) like handler
+ * - +io+ [IO|String] IO Object to read from
+ * - +options+ [Hash] options parse options
+ *   - *:convert_special* [true|false] flag indicating special characters like &lt; are converted
+ *   - *:symbolize* [true|false] flag indicating the parser symbolize element and attribute names
+ *   - *:smart* [true|false] flag indicating the parser uses hints if available (use with html)
+ *   - *:skip* [:skip_none|:skip_return|:skip_white|:skip_off] flag indicating the parser skips \\r or collpase white
+ * space into a single space. Default (skip space)
+ *   - *: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.
+ */
+static VALUE sax_parse(int argc, VALUE *argv, VALUE self) {
+    struct _saxOptions options;
+
+    options.symbolize       = (No != ox_default_options.sym_keys);
+    options.convert_special = ox_default_options.convert_special;
+    options.smart           = (Yes == ox_default_options.smart);
+    options.skip            = ox_default_options.skip;
+    options.hints           = NULL;
+    strcpy(options.strip_ns, ox_default_options.strip_ns);
+
+    if (argc < 2) {
+        rb_raise(ox_parse_error_class, "Wrong number of arguments to sax_parse.\n");
+    }
+    if (3 <= argc && rb_cHash == rb_obj_class(argv[2])) {
+        VALUE h = argv[2];
+        VALUE v;
+
+        if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
+            options.convert_special = (Qtrue == v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, smart_sym))) {
+            options.smart = (Qtrue == v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, symbolize_sym))) {
+            options.symbolize = (Qtrue == v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, skip_sym))) {
+            if (skip_return_sym == v) {
+                options.skip = CrSkip;
+            } else if (skip_white_sym == v) {
+                options.skip = SpcSkip;
+            } else if (skip_none_sym == v) {
+                options.skip = NoSkip;
+            } else if (skip_off_sym == v) {
+                options.skip = OffSkip;
+            }
+        }
+        if (Qnil != (v = rb_hash_lookup(h, strip_namespace_sym))) {
+            if (Qfalse == v) {
+                *options.strip_ns = '\0';
+            } else if (Qtrue == v) {
+                *options.strip_ns   = '*';
+                options.strip_ns[1] = '\0';
+            } else {
+                long slen;
+
+                Check_Type(v, T_STRING);
+                slen = RSTRING_LEN(v);
+                if (sizeof(options.strip_ns) - 1 < (size_t)slen) {
+                    rb_raise(ox_parse_error_class,
+                             ":strip_namespace can be no longer than %d characters.",
+                             (int)sizeof(options.strip_ns) - 1);
+                }
+                strncpy(options.strip_ns, StringValuePtr(v), sizeof(options.strip_ns) - 1);
+                options.strip_ns[sizeof(options.strip_ns) - 1] = '\0';
+            }
+        }
+    }
+    ox_sax_parse(argv[0], argv[1], &options);
+
+    return Qnil;
+}
+
+/* call-seq: sax_html(handler, io, options)
+ *
+ * Parses an IO stream or file containing an XML document. Raises an exception
+ * if the XML is malformed or the classes specified are not valid.
+ * - +handler+ [Ox::Sax] SAX (responds to OX::Sax methods) like handler
+ * - +io+ [IO|String] IO Object to read from
+ * - +options+ [Hash] options parse options
+ *   - *:convert_special* [true|false] flag indicating special characters like &lt; are converted
+ *   - *:symbolize* [true|false] flag indicating the parser symbolize element and attribute names
+ *   - *:skip* [:skip_none|:skip_return|:skip_white|:skip_off] flag indicating the parser skips \\r or collapse white
+ * space into a single space. Default (skip space)
+ *   - *: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
+ *     - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *     - _:block_ - block this and all children callbacks
+ *     - _:off_ - block this element and it's children unless the child element is active
+ *     - _:abort_ - abort the html processing and return
+ */
+static VALUE sax_html(int argc, VALUE *argv, VALUE self) {
+    struct _saxOptions options;
+    bool               free_hints = false;
+
+    options.symbolize       = (No != ox_default_options.sym_keys);
+    options.convert_special = ox_default_options.convert_special;
+    options.smart           = true;
+    options.skip            = ox_default_options.skip;
+    options.hints           = ox_default_options.html_hints;
+    if (NULL == options.hints) {
+        options.hints = ox_hints_html();
+    }
+    *options.strip_ns = '\0';
+
+    if (argc < 2) {
+        rb_raise(ox_parse_error_class, "Wrong number of arguments to sax_html.\n");
+    }
+    if (3 <= argc && rb_cHash == rb_obj_class(argv[2])) {
+        volatile VALUE h = argv[2];
+        volatile VALUE v;
+
+        if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
+            options.convert_special = (Qtrue == v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, symbolize_sym))) {
+            options.symbolize = (Qtrue == v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, skip_sym))) {
+            if (skip_return_sym == v) {
+                options.skip = CrSkip;
+            } else if (skip_white_sym == v) {
+                options.skip = SpcSkip;
+            } else if (skip_none_sym == v) {
+                options.skip = NoSkip;
+            } else if (skip_off_sym == v) {
+                options.skip = OffSkip;
+            }
+        }
+        if (Qnil != (v = rb_hash_lookup(h, overlay_sym))) {
+            int cnt;
+
+            Check_Type(v, T_HASH);
+            cnt = (int)RHASH_SIZE(v);
+            if (0 == cnt) {
+                options.hints = ox_hints_html();
+            } else {
+                options.hints = ox_hints_dup(options.hints);
+                free_hints    = true;
+                rb_hash_foreach(v, set_overlay, (VALUE)options.hints);
+            }
+        }
+    }
+    ox_sax_parse(argv[0], argv[1], &options);
+    if (free_hints) {
+        ox_hints_destroy(options.hints);
+    }
+    return Qnil;
+}
+
+static void parse_dump_options(VALUE ropts, Options copts) {
+    struct _yesNoOpt ynos[] = {{with_xml_sym, &copts->with_xml},
+                               {with_dtd_sym, &copts->with_dtd},
+                               {with_instruct_sym, &copts->with_instruct},
+                               {xsd_date_sym, &copts->xsd_date},
+                               {circular_sym, &copts->circular},
+                               {Qnil, 0}};
+    YesNoOpt         o;
+
+    if (rb_cHash == rb_obj_class(ropts)) {
+        VALUE v;
+
+        if (Qnil != (v = rb_hash_lookup(ropts, ox_indent_sym))) {
+            if (rb_cInteger != rb_obj_class(v) && T_FIXNUM != rb_type(v)) {
+                rb_raise(ox_parse_error_class, ":indent must be a Fixnum.\n");
+            }
+            copts->indent = NUM2INT(v);
+        }
+        if (Qnil != (v = rb_hash_lookup(ropts, trace_sym))) {
+            if (rb_cInteger != rb_obj_class(v) && T_FIXNUM != rb_type(v)) {
+                rb_raise(ox_parse_error_class, ":trace must be a Fixnum.\n");
+            }
+            copts->trace = NUM2INT(v);
+        }
+        if (Qnil != (v = rb_hash_lookup(ropts, ox_encoding_sym))) {
+            if (rb_cString != rb_obj_class(v)) {
+                rb_raise(ox_parse_error_class, ":encoding must be a String.\n");
+            }
+            strncpy(copts->encoding, StringValuePtr(v), sizeof(copts->encoding) - 1);
+        }
+        if (Qnil != (v = rb_hash_lookup(ropts, no_empty_sym))) {
+            copts->no_empty = (v == Qtrue);
+        }
+        if (Qnil != (v = rb_hash_lookup(ropts, effort_sym))) {
+            if (auto_define_sym == v) {
+                copts->effort = AutoEffort;
+            } else if (tolerant_sym == v) {
+                copts->effort = TolerantEffort;
+            } else if (strict_sym == v) {
+                copts->effort = StrictEffort;
+            } else {
+                rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
+            }
+        }
+        v = rb_hash_lookup(ropts, invalid_replace_sym);
+        if (Qnil == v) {
+            if (Qtrue == rb_funcall(ropts, has_key_id, 1, invalid_replace_sym)) {
+                copts->allow_invalid = Yes;
+            }
+        } else {
+            long slen;
+
+            Check_Type(v, T_STRING);
+            slen = RSTRING_LEN(v);
+            if (sizeof(copts->inv_repl) - 2 < (size_t)slen) {
+                rb_raise(ox_parse_error_class,
+                         ":invalid_replace can be no longer than %d characters.",
+                         (int)sizeof(copts->inv_repl) - 2);
+            }
+            strncpy(copts->inv_repl + 1, StringValuePtr(v), sizeof(copts->inv_repl) - 1);
+            copts->inv_repl[sizeof(copts->inv_repl) - 1] = '\0';
+            *copts->inv_repl                             = (char)slen;
+            copts->allow_invalid                         = No;
+        }
+        v = rb_hash_lookup(ropts, margin_sym);
+        if (Qnil != v) {
+            long slen;
+
+            Check_Type(v, T_STRING);
+            slen = RSTRING_LEN(v);
+            if (sizeof(copts->margin) - 2 < (size_t)slen) {
+                rb_raise(ox_parse_error_class,
+                         ":margin can be no longer than %d characters.",
+                         (int)sizeof(copts->margin) - 2);
+            }
+            strncpy(copts->margin, StringValuePtr(v), sizeof(copts->margin) - 1);
+            copts->margin[sizeof(copts->margin) - 1] = '\0';
+            copts->margin_len                        = (char)slen;
+        }
+
+        for (o = ynos; 0 != o->attr; o++) {
+            if (Qnil != (v = rb_hash_lookup(ropts, o->sym))) {
+                VALUE c = rb_obj_class(v);
+
+                if (rb_cTrueClass == c) {
+                    *o->attr = Yes;
+                } else if (rb_cFalseClass == c) {
+                    *o->attr = No;
+                } else {
+                    rb_raise(ox_parse_error_class, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
+                }
+            }
+        }
+    }
+}
+
+/* call-seq: dump(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
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
+ *
+ * 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 dump(int argc, VALUE *argv, VALUE self) {
+    char           *xml;
+    struct _options copts = ox_default_options;
+    VALUE           rstr;
+
+    if (2 == argc) {
+        parse_dump_options(argv[1], &copts);
+    }
+    if (0 == (xml = ox_write_obj_to_str(*argv, &copts))) {
+        rb_raise(rb_eNoMemError, "Not enough memory.\n");
+    }
+    rstr = rb_str_new2(xml);
+    if ('\0' != *copts.encoding) {
+        rb_enc_associate(rstr, rb_enc_find(copts.encoding));
+    }
+    xfree(xml);
+
+    return rstr;
+}
+
+/* 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
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
+ *
+ * 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
+ * - +obj+ [Object] Object to serialize as an XML document String
+ * - +options+ [Hash] formating options
+ *   - *:indent* [Fixnum] format expected
+ *   - *: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
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
+ *
+ * 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_file(int argc, VALUE *argv, VALUE self) {
+    struct _options copts = ox_default_options;
+
+    if (3 == argc) {
+        parse_dump_options(argv[2], &copts);
+    }
+    Check_Type(*argv, T_STRING);
+    ox_write_obj_to_file(argv[1], StringValuePtr(*argv), &copts);
+
+    return Qnil;
+}
+
+#if WITH_CACHE_TESTS
+extern void ox_cache_test(void);
+
+static VALUE cache_test(VALUE self) {
+    ox_cache_test();
+    return Qnil;
+}
+
+extern void ox_cache8_test(void);
+
+static VALUE cache8_test(VALUE self) {
+    ox_cache8_test();
+    return Qnil;
+}
+#endif
+
+void Init_ox(void) {
+#if HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
+    Ox = rb_define_module("Ox");
+
+    rb_define_module_function(Ox, "default_options", get_def_opts, 0);
+    rb_define_module_function(Ox, "default_options=", set_def_opts, 1);
+
+    rb_define_module_function(Ox, "parse_obj", to_obj, 1);
+    rb_define_module_function(Ox, "parse", to_gen, 1);
+    rb_define_module_function(Ox, "load", load_str, -1);
+    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", to_xml, -1);
+    rb_define_module_function(Ox, "dump", dump, -1);
+
+    rb_define_module_function(Ox, "load_file", load_file, -1);
+    rb_define_module_function(Ox, "to_file", to_file, -1);
+
+    rb_define_module_function(Ox, "sax_html_overlay", sax_html_overlay, 0);
+
+    ox_init_builder(Ox);
+
+    rb_require("time");
+    rb_require("date");
+    // rb_require("bigdecimal");
+    rb_require("stringio");
+
+    ox_abort_id             = rb_intern("abort");
+    ox_at_column_id         = rb_intern("@column");
+    ox_at_content_id        = rb_intern("@content");
+    ox_at_id                = rb_intern("at");
+    ox_at_line_id           = rb_intern("@line");
+    ox_at_pos_id            = rb_intern("@pos");
+    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_attrs_done_id        = rb_intern("attrs_done");
+    ox_beg_id               = rb_intern("@beg");
+    ox_bigdecimal_id        = rb_intern("BigDecimal");
+    ox_call_id              = rb_intern("call");
+    ox_cdata_id             = rb_intern("cdata");
+    ox_comment_id           = rb_intern("comment");
+    ox_den_id               = rb_intern("@den");
+    ox_doctype_id           = rb_intern("doctype");
+    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_external_encoding_id = rb_intern("external_encoding");
+    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");
+    ox_keys_id              = rb_intern("keys");
+    ox_local_id             = rb_intern("local");
+    ox_mesg_id              = rb_intern("mesg");
+    ox_message_id           = rb_intern("message");
+    ox_nodes_id             = rb_intern("@nodes");
+    ox_new_id               = rb_intern("new");
+    ox_num_id               = rb_intern("@num");
+    ox_parse_id             = rb_intern("parse");
+    ox_pos_id               = rb_intern("pos");
+    ox_read_id              = rb_intern("read");
+    ox_readpartial_id       = rb_intern("readpartial");
+    ox_start_element_id     = rb_intern("start_element");
+    ox_string_id            = rb_intern("string");
+    ox_text_id              = rb_intern("text");
+    ox_to_c_id              = rb_intern("to_c");
+    ox_value_id             = rb_intern("value");
+
+    encoding_id = rb_intern("encoding");
+    has_key_id  = rb_intern("has_key?");
+
+    rb_require("ox/version");
+    rb_require("ox/error");
+    rb_require("ox/hasattrs");
+    rb_require("ox/node");
+    rb_require("ox/comment");
+    rb_require("ox/instruct");
+    rb_require("ox/cdata");
+    rb_require("ox/doctype");
+    rb_require("ox/element");
+    rb_require("ox/document");
+    rb_require("ox/bag");
+    rb_require("ox/sax");
+
+    ox_time_class         = rb_const_get(rb_cObject, rb_intern("Time"));
+    ox_date_class         = rb_const_get(rb_cObject, rb_intern("Date"));
+    ox_parse_error_class  = rb_const_get_at(Ox, rb_intern("ParseError"));
+    ox_syntax_error_class = rb_const_get_at(Ox, rb_intern("SyntaxError"));
+    ox_arg_error_class    = rb_const_get_at(Ox, rb_intern("ArgError"));
+    ox_struct_class       = rb_const_get(rb_cObject, rb_intern("Struct"));
+    ox_stringio_class     = rb_const_get(rb_cObject, rb_intern("StringIO"));
+
+    abort_sym = ID2SYM(rb_intern("abort"));
+    rb_gc_register_address(&abort_sym);
+    active_sym = ID2SYM(rb_intern("active"));
+    rb_gc_register_address(&active_sym);
+    attr_key_mod_sym = ID2SYM(rb_intern("attr_key_mod"));
+    rb_gc_register_address(&attr_key_mod_sym);
+    auto_define_sym = ID2SYM(rb_intern("auto_define"));
+    rb_gc_register_address(&auto_define_sym);
+    auto_sym = ID2SYM(rb_intern("auto"));
+    rb_gc_register_address(&auto_sym);
+    block_sym = ID2SYM(rb_intern("block"));
+    rb_gc_register_address(&block_sym);
+    circular_sym = ID2SYM(rb_intern("circular"));
+    rb_gc_register_address(&circular_sym);
+    convert_special_sym = ID2SYM(rb_intern("convert_special"));
+    rb_gc_register_address(&convert_special_sym);
+    effort_sym = ID2SYM(rb_intern("effort"));
+    rb_gc_register_address(&effort_sym);
+    element_key_mod_sym = ID2SYM(rb_intern("element_key_mod"));
+    rb_gc_register_address(&element_key_mod_sym);
+    generic_sym = ID2SYM(rb_intern("generic"));
+    rb_gc_register_address(&generic_sym);
+    hash_no_attrs_sym = ID2SYM(rb_intern("hash_no_attrs"));
+    rb_gc_register_address(&hash_no_attrs_sym);
+    hash_sym = ID2SYM(rb_intern("hash"));
+    rb_gc_register_address(&hash_sym);
+    inactive_sym = ID2SYM(rb_intern("inactive"));
+    rb_gc_register_address(&inactive_sym);
+    invalid_replace_sym = ID2SYM(rb_intern("invalid_replace"));
+    rb_gc_register_address(&invalid_replace_sym);
+    limited_sym = ID2SYM(rb_intern("limited"));
+    rb_gc_register_address(&limited_sym);
+    margin_sym = ID2SYM(rb_intern("margin"));
+    rb_gc_register_address(&margin_sym);
+    mode_sym = ID2SYM(rb_intern("mode"));
+    rb_gc_register_address(&mode_sym);
+    nest_ok_sym = ID2SYM(rb_intern("nest_ok"));
+    rb_gc_register_address(&nest_ok_sym);
+    no_empty_sym = ID2SYM(rb_intern("no_empty"));
+    rb_gc_register_address(&no_empty_sym);
+    object_sym = ID2SYM(rb_intern("object"));
+    rb_gc_register_address(&object_sym);
+    off_sym = ID2SYM(rb_intern("off"));
+    rb_gc_register_address(&off_sym);
+    opt_format_sym = ID2SYM(rb_intern("opt_format"));
+    rb_gc_register_address(&opt_format_sym);
+    optimized_sym = ID2SYM(rb_intern("optimized"));
+    rb_gc_register_address(&optimized_sym);
+    overlay_sym = ID2SYM(rb_intern("overlay"));
+    rb_gc_register_address(&overlay_sym);
+    ox_encoding_sym = ID2SYM(rb_intern("encoding"));
+    rb_gc_register_address(&ox_encoding_sym);
+    ox_indent_sym = ID2SYM(rb_intern("indent"));
+    rb_gc_register_address(&ox_indent_sym);
+    ox_size_sym = ID2SYM(rb_intern("size"));
+    rb_gc_register_address(&ox_size_sym);
+    ox_standalone_sym = ID2SYM(rb_intern("standalone"));
+    rb_gc_register_address(&ox_standalone_sym);
+    ox_version_sym = ID2SYM(rb_intern("version"));
+    rb_gc_register_address(&ox_version_sym);
+    skip_none_sym = ID2SYM(rb_intern("skip_none"));
+    rb_gc_register_address(&skip_none_sym);
+    skip_off_sym = ID2SYM(rb_intern("skip_off"));
+    rb_gc_register_address(&skip_off_sym);
+    skip_return_sym = ID2SYM(rb_intern("skip_return"));
+    rb_gc_register_address(&skip_return_sym);
+    skip_sym = ID2SYM(rb_intern("skip"));
+    rb_gc_register_address(&skip_sym);
+    skip_white_sym = ID2SYM(rb_intern("skip_white"));
+    rb_gc_register_address(&skip_white_sym);
+    smart_sym = ID2SYM(rb_intern("smart"));
+    rb_gc_register_address(&smart_sym);
+    strict_sym = ID2SYM(rb_intern("strict"));
+    rb_gc_register_address(&strict_sym);
+    strip_namespace_sym = ID2SYM(rb_intern("strip_namespace"));
+    rb_gc_register_address(&strip_namespace_sym);
+    symbolize_keys_sym = ID2SYM(rb_intern("symbolize_keys"));
+    rb_gc_register_address(&symbolize_keys_sym);
+    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);
+    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));
+    rb_gc_register_address(&xsd_date_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_sym_bank = rb_ary_new();
+    rb_gc_register_address(&ox_sym_bank);
+
+    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_raw_clas      = rb_const_get_at(Ox, rb_intern("Raw"));
+    ox_doctype_clas  = rb_const_get_at(Ox, rb_intern("DocType"));
+    ox_cdata_clas    = rb_const_get_at(Ox, rb_intern("CData"));
+    ox_bag_clas      = rb_const_get_at(Ox, rb_intern("Bag"));
+
+    // Classes can move in more recent versions so register them all.
+    rb_gc_register_address(&Ox);
+    rb_gc_register_address(&ox_arg_error_class);
+    rb_gc_register_address(&ox_bag_clas);
+    rb_gc_register_address(&ox_bag_clas);
+    rb_gc_register_address(&ox_cdata_clas);
+    rb_gc_register_address(&ox_cdata_clas);
+    rb_gc_register_address(&ox_comment_clas);
+    rb_gc_register_address(&ox_comment_clas);
+    rb_gc_register_address(&ox_date_class);
+    rb_gc_register_address(&ox_doctype_clas);
+    rb_gc_register_address(&ox_doctype_clas);
+    rb_gc_register_address(&ox_document_clas);
+    rb_gc_register_address(&ox_document_clas);
+    rb_gc_register_address(&ox_element_clas);
+    rb_gc_register_address(&ox_element_clas);
+    rb_gc_register_address(&ox_encoding_sym);
+    rb_gc_register_address(&ox_indent_sym);
+    rb_gc_register_address(&ox_instruct_clas);
+    rb_gc_register_address(&ox_instruct_clas);
+    rb_gc_register_address(&ox_parse_error_class);
+    rb_gc_register_address(&ox_raw_clas);
+    rb_gc_register_address(&ox_raw_clas);
+    rb_gc_register_address(&ox_size_sym);
+    rb_gc_register_address(&ox_standalone_sym);
+    rb_gc_register_address(&ox_stringio_class);
+    rb_gc_register_address(&ox_struct_class);
+    rb_gc_register_address(&ox_syntax_error_class);
+    rb_gc_register_address(&ox_time_class);
+    rb_gc_register_address(&ox_version_sym);
+
+    slot_cache_new(&ox_class_cache);
+
+    ox_sax_define();
+    ox_hash_init();
+
+#if WITH_CACHE_TESTS
+    // space added to stop yardoc from trying to document
+    rb_define _module_function(Ox, "cache_test", cache_test, 0);
+    rb_define _module_function(Ox, "cache8_test", cache8_test, 0);
+#endif
+
+    ox_utf8_encoding = rb_enc_find("UTF-8");
+}
+
+#if __GNUC__ > 4
+_Noreturn void
+#else
+void
+#endif
+_ox_raise_error(const char *msg, const char *xml, const char *current, const char *file, int line) {
+    int xline = 1;
+    int col   = 1;
+
+    for (; xml < current && '\n' != *current; current--) {
+        col++;
+    }
+    for (; xml < current; current--) {
+        if ('\n' == *current) {
+            xline++;
+        }
+    }
+    rb_gc_enable();
+    rb_raise(ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);
+}