ox 1.1.1 → 1.2.0

data/ext/ox/base64.c

@@ -29,6 +29,7 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
 
 #include "base64.h"
 
@@ -64,10 +65,10 @@ to_base64(const u_char *src, int len, char *b64) {
 	b1 = *src++;
 	b2 = *src++;
 	b3 = *src++;
-	*b64++ = digits[b1 >> 2];
-	*b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
-	*b64++ = digits[((b2 & 0x0F) << 2) | (b3 >> 6)];
-	*b64++ = digits[b3 & 0x3F];
+	*b64++ = digits[(u_char)(b1 >> 2)];
+	*b64++ = digits[(u_char)(((b1 & 0x03) << 4) | (b2 >> 4))];
+	*b64++ = digits[(u_char)(((b2 & 0x0F) << 2) | (b3 >> 6))];
+	*b64++ = digits[(u_char)(b3 & 0x3F)];
     }
     if (1 == len3) {
 	b1 = *src++;
@@ -90,7 +91,7 @@ unsigned long
 b64_orig_size(const char *text) {
     const char          *start = text;
     unsigned long        size = 0;
-    
+
     if ('\0' != *text) {
         for (; 0 != *text; text++) { }
         size = (text - start) * 3 / 4;

data/ext/ox/dump.c

@@ -67,10 +67,11 @@ typedef struct _Out {
     int                 depth; // used by dumpHash
 } *Out;
 
-static void     dump_obj_to_xml(VALUE obj, int indent, int xsd_date, int circular, Out out);
+static void     dump_obj_to_xml(VALUE obj, Options copts, Out out);
 
+static void     dump_first_obj(VALUE obj, Options copts, Out out);
 static void     dump_obj(ID aid, VALUE obj, unsigned int depth, Out out);
-static void     dump_gen_doc(VALUE obj, unsigned int depth, Out out);
+static void     dump_gen_doc(VALUE obj, unsigned int depth, Options copts, Out out);
 static void     dump_gen_element(VALUE obj, unsigned int depth, Out out);
 static int      dump_gen_attr(VALUE key, VALUE value, Out out);
 static int      dump_gen_nodes(VALUE obj, unsigned int depth, Out out);
@@ -113,6 +114,30 @@ is_xml_friendly(const u_char *str, int len) {
     return 1;
 }
 
+inline static Type
+obj_class_code(VALUE obj) {
+    switch (rb_type(obj)) {
+    case RUBY_T_NIL:            return NilClassCode;
+    case RUBY_T_ARRAY:          return ArrayCode;
+    case RUBY_T_HASH:           return HashCode;
+    case RUBY_T_TRUE:           return TrueClassCode;
+    case RUBY_T_FALSE:          return FalseClassCode;
+    case RUBY_T_FIXNUM:         return FixnumCode;
+    case RUBY_T_FLOAT:          return FloatCode;
+    case RUBY_T_STRING:         return (is_xml_friendly((u_char*)StringValuePtr(obj), (int)RSTRING_LEN(obj))) ? StringCode : Base64Code;
+    case RUBY_T_SYMBOL:         return SymbolCode;
+    case RUBY_T_DATA:           return (rb_cTime == rb_obj_class(obj)) ? TimeCode : 0;
+    case RUBY_T_STRUCT:         return (rb_cRange == rb_obj_class(obj)) ? RangeCode : StructCode;
+    case RUBY_T_OBJECT:         return (ox_document_clas == rb_obj_class(obj) || ox_element_clas == rb_obj_class(obj)) ? RawCode : ObjectCode;
+    case RUBY_T_REGEXP:         return RegexpCode;
+    case RUBY_T_BIGNUM:         return BignumCode;
+    case RUBY_T_COMPLEX:        return ComplexCode;
+    case RUBY_T_RATIONAL:       return RationalCode;
+    case RUBY_T_CLASS:          return ClassCode;
+    default:                    return 0;
+    }
+}
+
 inline static void
 fill_indent(Out out, int cnt) {
     if (0 <= cnt) {
@@ -221,7 +246,9 @@ dump_start(Out out, Element e) {
     if (out->end - out->cur < (long)size) {
         grow(out, size);
     }
-    fill_indent(out, e->indent);
+    if (out->buf < out->cur) {
+        fill_indent(out, e->indent);
+    }
     *out->cur++ = '<';
     *out->cur++ = e->type;
     if (0 < e->attr.len) {
@@ -361,6 +388,33 @@ dump_time_xsd(Out out, VALUE obj) {
             tzsign, tzhour, tzmin);
 }
 
+static void
+dump_first_obj(VALUE obj, Options copts, Out out) {
+    char        buf[128];
+    int         cnt;
+
+    if (Yes == copts->with_xml) {
+        if ('\0' == *copts->encoding) {
+            dump_value(out, "<?xml version=\"1.0\"?>", 21);
+        } else {
+            cnt = sprintf(buf, "<?xml version=\"1.0\" encoding=\"%s\"?>", copts->encoding);
+            dump_value(out, buf, cnt);
+        }
+    }
+    if (Yes == copts->with_instruct) {
+        cnt = sprintf(buf, "%s<?ox version=\"1.0\" mode=\"object\"%s%s?>",
+                      (out->buf < out->cur) ? "\n" : "",
+                      (Yes == copts->circular) ? " circular=\"yes\"" : ((No == copts->circular) ? " circular=\"no\"" : ""),
+                      (Yes == copts->xsd_date) ? " xsd_date=\"yes\"" : ((No == copts->xsd_date) ? " xsd_date=\"no\"" : ""));
+        dump_value(out, buf, cnt);
+    }
+    if (Yes == copts->with_dtd) {
+        cnt = sprintf(buf, "%s<!DOCTYPE %c SYSTEM \"ox.dtd\">", (out->buf < out->cur) ? "\n" : "", obj_class_code(obj));
+        dump_value(out, buf, cnt);
+    }
+    dump_obj(0, obj, 0, out);
+}
+
 static void
 dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
     struct _Element     e;
@@ -376,12 +430,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
     }
     e.closed = 0;
     if (0 == depth) {
-        if (0 <= out->indent) {
-            e.indent = 0;
-        } else {
-            e.indent = -1;
-        }
-        dump_value(out, "<?xml version=\"1.0\"?>", 21);
+        e.indent = (0 <= out->indent) ? 0 : -1;
     } else if (0 > out->indent) {
         e.indent = -1;
     } else if (0 == out->indent) {
@@ -573,7 +622,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
         if (ox_document_clas == clas) {
             e.type = RawCode;
             out->w_start(out, &e);
-            dump_gen_doc(obj, depth + 1, out);
+            dump_gen_doc(obj, depth + 1, 0, out);
             out->w_end(out, &e);
         } else if (ox_element_clas == clas) {
             e.type = RawCode;
@@ -702,15 +751,24 @@ dump_hash(VALUE key, VALUE value, Out out) {
 }
 
 static void
-dump_gen_doc(VALUE obj, unsigned int depth, Out out) {
+dump_gen_doc(VALUE obj, unsigned int depth, Options copts, Out out) {
     VALUE       attrs = rb_attr_get(obj, attributes_id);
     VALUE       nodes = rb_attr_get(obj, nodes_id);
 
-    dump_value(out, "<?xml", 5);
-    if (Qnil != attrs) {
-        rb_hash_foreach(attrs, dump_gen_attr, (VALUE)out);
+    if (Yes == copts->with_xml) {
+        dump_value(out, "<?xml", 5);
+        if (Qnil != attrs) {
+            rb_hash_foreach(attrs, dump_gen_attr, (VALUE)out);
+        }
+        dump_value(out, "?>", 2);
+    }
+    if (Yes == copts->with_instruct) {
+        if (out->buf < out->cur) {
+            dump_value(out, "\n<?ox version=\"1.0\" mode=\"generic\"?>", 36);
+        } else {
+            dump_value(out, "<?ox version=\"1.0\" mode=\"generic\"?>", 35);
+        }
     }
-    dump_value(out, "?>", 2);
     if (Qnil != nodes) {
         dump_gen_nodes(nodes, depth, out);
     }
@@ -848,47 +906,47 @@ dump_gen_val_node(VALUE obj, unsigned int depth,
 }
 
 static void
-dump_obj_to_xml(VALUE obj, int indent, int xsd_date, int circular, Out out) {
+dump_obj_to_xml(VALUE obj, Options copts, Out out) {
     VALUE       clas = rb_obj_class(obj);
 
-    out->w_time = (xsd_date) ? dump_time_xsd : dump_time_thin;
+    out->w_time = (Yes == copts->xsd_date) ? dump_time_xsd : dump_time_thin;
     out->buf = (char*)malloc(65336);
     out->end = out->buf + 65336;
     out->cur = out->buf;
     out->circ_cache = 0;
     out->circ_cnt = 0;
-    if (circular) {
+    if (Yes == copts->circular) {
         ox_cache8_new(&out->circ_cache);
     }
-    out->indent = indent;
+    out->indent = copts->indent;
     if (ox_document_clas == clas) {
-        dump_gen_doc(obj, -1, out);
+        dump_gen_doc(obj, -1, copts, out);
     } else if (ox_element_clas == clas) {
         dump_gen_element(obj, 0, out);
     } else {
         out->w_start = dump_start;
         out->w_end = dump_end;
-        dump_obj(0, obj, 0, out);
+        dump_first_obj(obj, copts, out);
     }
     dump_value(out, "\n", 1);
 }
 
 char*
-write_obj_to_str(VALUE obj, int indent, int xsd_date, int circular) {
+write_obj_to_str(VALUE obj, Options copts) {
     struct _Out out;
     
-    dump_obj_to_xml(obj, indent, xsd_date, circular, &out);
+    dump_obj_to_xml(obj, copts, &out);
 
     return out.buf;
 }
 
 void
-write_obj_to_file(VALUE obj, const char *path, int indent, int xsd_date, int circular) {
+write_obj_to_file(VALUE obj, const char *path, Options copts) {
     struct _Out out;
     size_t      size;
     FILE        *f;    
 
-    dump_obj_to_xml(obj, indent, xsd_date, circular, &out);
+    dump_obj_to_xml(obj, copts, &out);
     size = out.cur - out.buf;
     if (0 == (f = fopen(path, "w"))) {
         rb_raise(rb_eIOError, "%s\n", strerror(errno));

data/ext/ox/gen_load.c

@@ -37,7 +37,8 @@
 #include "ruby.h"
 #include "ox.h"
 
-static void     add_prolog(PInfo pi, const char *version, const char *encoding, const char *standalone);
+static void     instruct(PInfo pi, const char *target, Attr attrs);
+static void     nomode_instruct(PInfo pi, const char *target, Attr attrs);
 static void     add_doctype(PInfo pi, const char *docType);
 static void     add_comment(PInfo pi, const char *comment);
 static void     add_cdata(PInfo pi, const char *cdata, size_t len);
@@ -45,8 +46,10 @@ static void     add_text(PInfo pi, char *text, int closed);
 static void     add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren);
 static void     end_element(PInfo pi, const char *ename);
 
+extern ParseCallbacks   ox_obj_callbacks;
+
 struct _ParseCallbacks   _ox_gen_callbacks = {
-    add_prolog,
+    instruct, // instruct,
     add_doctype,
     add_comment,
     add_cdata,
@@ -69,33 +72,109 @@ struct _ParseCallbacks   _ox_limited_callbacks = {
 
 ParseCallbacks   ox_limited_callbacks = &_ox_limited_callbacks;
 
+struct _ParseCallbacks   _ox_nomode_callbacks = {
+    nomode_instruct,
+    add_doctype,
+    add_comment,
+    add_cdata,
+    add_text,
+    add_element,
+    end_element,
+};
+
+ParseCallbacks   ox_nomode_callbacks = &_ox_nomode_callbacks;
+
 static void
-add_prolog(PInfo pi, const char *version, const char *encoding, const char *standalone) {
-    VALUE       doc;
-    VALUE       ah;
-    VALUE       nodes;
-    
-    if (0 != pi->h) { // top level object
-        rb_raise(rb_eEncodingError, "Prolog must be the first element in an XML document.\n");
-    }
-    pi->h = pi->helpers;
-    doc = rb_obj_alloc(ox_document_clas);
-    ah = rb_hash_new();
-    if (0 != version) {
-        rb_hash_aset(ah, version_sym, rb_str_new2(version));
-    }
-    if (0 != encoding) {
-        rb_hash_aset(ah, encoding_sym, rb_str_new2(encoding));
-        pi->encoding = rb_enc_find(encoding);
+instruct(PInfo pi, const char *target, Attr attrs) {
+    if (0 == strcmp("xml", target)) {
+        VALUE       doc;
+        VALUE       ah;
+        VALUE       nodes;
+
+        if (0 != pi->h) { // top level object
+            rb_raise(rb_eEncodingError, "Prolog must be the first element in an XML document.\n");
+        }
+        pi->h = pi->helpers;
+        doc = rb_obj_alloc(ox_document_clas);
+        ah = rb_hash_new();
+        for (; 0 != attrs->name; attrs++) {
+            rb_hash_aset(ah, ID2SYM(rb_intern(attrs->name)), rb_str_new2(attrs->value));
+            if (0 == strcmp("encoding", attrs->name)) {
+                pi->encoding = rb_enc_find(attrs->value);
+            }
+        }
+        nodes = rb_ary_new();
+        rb_ivar_set(doc, attributes_id, ah);
+        rb_ivar_set(doc, nodes_id, nodes);
+        pi->h->obj = nodes;
+        pi->obj = doc;
+    } else if (0 == strcmp("ox", target)) {
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("version", attrs->name)) {
+                if (0 != strcmp("1.0", attrs->value)) {
+                    rb_raise(rb_eEncodingError, "Only Ox XML Object version 1.0 supported, not %s.\n", attrs->value);
+                }
+            }
+            // ignore other instructions
+        }
+    } else {
+        if (TRACE <= pi->trace) {
+            printf("Processing instruction %s ignored.\n", target);
+        }
     }
-    if (0 != standalone) {
-        rb_hash_aset(ah, standalone_sym, rb_str_new2(standalone));
+}
+
+static void
+nomode_instruct(PInfo pi, const char *target, Attr attrs) {
+    if (0 == strcmp("xml", target)) {
+        VALUE       doc;
+        VALUE       ah;
+        VALUE       nodes;
+
+        if (0 != pi->h) { // top level object
+            rb_raise(rb_eEncodingError, "Prolog must be the first element in an XML document.\n");
+        }
+        pi->h = pi->helpers;
+        doc = rb_obj_alloc(ox_document_clas);
+        ah = rb_hash_new();
+        for (; 0 != attrs->name; attrs++) {
+            rb_hash_aset(ah, ID2SYM(rb_intern(attrs->name)), rb_str_new2(attrs->value));
+            if (0 == strcmp("encoding", attrs->name)) {
+                pi->encoding = rb_enc_find(attrs->value);
+            }
+        }
+        nodes = rb_ary_new();
+        rb_ivar_set(doc, attributes_id, ah);
+        rb_ivar_set(doc, nodes_id, nodes);
+        pi->h->obj = nodes;
+        pi->obj = doc;
+    } else if (0 == strcmp("ox", target)) {
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("version", attrs->name)) {
+                if (0 != strcmp("1.0", attrs->value)) {
+                    rb_raise(rb_eEncodingError, "Only Ox XML Object version 1.0 supported, not %s.\n", attrs->value);
+                }
+            } else if (0 == strcmp("mode", attrs->name)) {
+                if (0 == strcmp("object", attrs->value)) {
+                    pi->pcb = ox_obj_callbacks;
+                    pi->obj = Qnil;
+                    pi->h = 0;
+                } else if (0 == strcmp("generic", attrs->value)) {
+                    pi->pcb = ox_gen_callbacks;
+                } else if (0 == strcmp("limited", attrs->value)) {
+                    pi->pcb = ox_limited_callbacks;
+                    pi->obj = Qnil;
+                    pi->h = 0;
+                } else {
+                    rb_raise(rb_eEncodingError, "%s is not a valid processing instruction mode.\n", attrs->value);
+                }
+            }
+        }
+    } else {
+        if (TRACE <= pi->trace) {
+            printf("Processing instruction %s ignored.\n", target);
+        }
     }
-    nodes = rb_ary_new();
-    rb_ivar_set(doc, attributes_id, ah);
-    rb_ivar_set(doc, nodes_id, nodes);
-    pi->h->obj = nodes;
-    pi->obj = doc;
 }
 
 static void

data/ext/ox/obj_load.c

@@ -40,7 +40,7 @@
 #include "base64.h"
 #include "ox.h"
 
-static void     add_prolog(PInfo pi, const char *version, const char *encoding, const char *standalone);
+static void     instruct(PInfo pi, const char *target, Attr attrs);
 static void     add_text(PInfo pi, char *text, int closed);
 static void     add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren);
 static void     end_element(PInfo pi, const char *ename);
@@ -65,7 +65,7 @@ static void             fill_indent(PInfo pi, char *buf, size_t size);
 
 
 struct _ParseCallbacks   _ox_obj_callbacks = {
-    add_prolog,
+    instruct, // instruct,
     0, // add_doctype,
     0, // add_comment,
     0, // add_cdata,
@@ -342,9 +342,13 @@ parse_regexp(const char *text) {
 }
 
 static void
-add_prolog(PInfo pi, const char *version, const char *encoding, const char *standalone) {
-    if (0 != encoding) {
-        pi->encoding = rb_enc_find(encoding);
+instruct(PInfo pi, const char *target, Attr attrs) {
+    if (0 == strcmp("xml", target)) {
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("encoding", attrs->name)) {
+                pi->encoding = rb_enc_find(attrs->value);
+            }
+        }
     }
 }
 

data/ext/ox/ox.c

@@ -36,6 +36,11 @@
 #include "ruby.h"
 #include "ox.h"
 
+typedef struct _YesNoOpt {
+    VALUE       sym;
+    char        *attr;
+} *YesNoOpt;
+
 void Init_ox();
 
 VALUE    Ox = Qnil;
@@ -76,6 +81,10 @@ VALUE   tolerant_sym;
 VALUE   effort_sym;
 VALUE   auto_define_sym;
 VALUE   trace_sym;
+VALUE   strict_sym;
+VALUE   with_dtd_sym;
+VALUE   with_instruct_sym;
+VALUE   with_xml_sym;
 VALUE   empty_string;
 VALUE   zero_fixnum;
 
@@ -92,11 +101,153 @@ Cache   symbol_cache = 0;
 Cache   class_cache = 0;
 Cache   attr_cache = 0;
 
+static struct _Options  default_options = {
+    { '\0' },           // encoding
+    2,                  // indent
+    0,                  // trace
+    No,                 // with_dtd
+    No,                 // with_xml
+    No,                 // with_instruct
+    No,                 // circular
+    No,                 // xsd_date
+    NoMode,             // mode
+    StrictEffort,       // effort
+};
+
 extern ParseCallbacks   ox_obj_callbacks;
 extern ParseCallbacks   ox_gen_callbacks;
 extern ParseCallbacks   ox_limited_callbacks;
+extern ParseCallbacks   ox_nomode_callbacks;
 
-static void     parse_dump_options(VALUE options, int *indent, int *xsd_date, int *circular);
+static void     parse_dump_options(VALUE ropts, Options copts);
+
+/* call-seq: default_options() => Hash
+ *
+ * Returns the default load and dump options as a Hash. The options are
+ * - 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|nil] load method to use for XML
+ * - effort: [:strict|:tolerant|:auto_define] set the tolerance level for loading
+ */
+static VALUE
+get_def_opts(VALUE self) {
+    VALUE       opts = rb_hash_new();
+    int         elen = (int)strlen(default_options.encoding);
+    
+    rb_hash_aset(opts, encoding_sym, (0 == elen) ? Qnil : rb_str_new(default_options.encoding, elen));
+    rb_hash_aset(opts, indent_sym, INT2FIX(default_options.indent));
+    rb_hash_aset(opts, trace_sym, INT2FIX(default_options.trace));
+    rb_hash_aset(opts, with_dtd_sym, (Yes == default_options.with_dtd) ? Qtrue : ((No == default_options.with_dtd) ? Qfalse : Qnil));
+    rb_hash_aset(opts, with_xml_sym, (Yes == default_options.with_xml) ? Qtrue : ((No == default_options.with_xml) ? Qfalse : Qnil));
+    rb_hash_aset(opts, with_instruct_sym, (Yes == default_options.with_instruct) ? Qtrue : ((No == default_options.with_instruct) ? Qfalse : Qnil));
+    rb_hash_aset(opts, circular_sym, (Yes == default_options.circular) ? Qtrue : ((No == default_options.circular) ? Qfalse : Qnil));
+    rb_hash_aset(opts, xsd_date_sym, (Yes == default_options.xsd_date) ? Qtrue : ((No == default_options.xsd_date) ? Qfalse : Qnil));
+    switch (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 NoMode:
+    default:            rb_hash_aset(opts, mode_sym, Qnil);             break;
+    }
+    switch (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;
+    }
+    return opts;
+}
+
+/* call-seq: default_options=(Hash)
+ *
+ * Sets the default options for load and dump. Options are:
+ * - 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|nil] load method to use for XML
+ * - effort: [:strict|:tolerant|:auto_define] set the tolerance level for loading
+ */
+static VALUE
+set_def_opts(VALUE self, VALUE opts) {
+    struct _YesNoOpt    ynos[] = {
+        { with_xml_sym, &default_options.with_xml },
+        { with_dtd_sym, &default_options.with_dtd },
+        { with_instruct_sym, &default_options.with_instruct },
+        { xsd_date_sym, &default_options.xsd_date },
+        { circular_sym, &default_options.circular },
+        { Qnil, 0 }
+    };
+    YesNoOpt    o;
+    VALUE       v;
+    
+    Check_Type(opts, T_HASH);
+
+    v = rb_hash_aref(opts, encoding_sym);
+    if (Qnil == v) {
+        *default_options.encoding = '\0';
+    } else {
+        Check_Type(v, T_STRING);
+        strncpy(default_options.encoding, StringValuePtr(v), sizeof(default_options.encoding) - 1);
+    }
+    v = rb_hash_aref(opts, indent_sym);
+    Check_Type(v, T_FIXNUM);
+    default_options.indent = FIX2INT(v);
+
+    v = rb_hash_aref(opts, trace_sym);
+    Check_Type(v, T_FIXNUM);
+    default_options.trace = FIX2INT(v);
+    
+    v = rb_hash_aref(opts, mode_sym);
+    if (Qnil == v) {
+        default_options.mode = NoMode;
+    } else if (object_sym == v) {
+        default_options.mode = ObjMode;
+    } else if (generic_sym == v) {
+        default_options.mode = GenMode;
+    } else if (limited_sym == v) {
+        default_options.mode = LimMode;
+    } else {
+        rb_raise(rb_eArgError, ":mode must be :object, :generic, :limited, or nil.\n");
+    }
+
+    v = rb_hash_aref(opts, effort_sym);
+    if (Qnil == v) {
+        default_options.effort = NoEffort;
+    } else if (strict_sym == v) {
+        default_options.effort = StrictEffort;
+    } else if (tolerant_sym == v) {
+        default_options.effort = TolerantEffort;
+    } else if (auto_define_sym == v) {
+        default_options.effort = AutoEffort;
+    } else {
+        rb_raise(rb_eArgError, ":effort must be :strict, :tolerant, :auto_define, or nil.\n");
+    }
+    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(rb_eArgError, "%s must be true, false, or nil.\n", StringValuePtr(o->sym));
+        }
+    }
+    return Qnil;
+}
 
 /* call-seq: parse_obj(xml) => Object
  *
@@ -139,68 +290,59 @@ to_gen(VALUE self, VALUE ruby_xml) {
     return obj;
 }
 
-typedef enum {
-    AutoMode = 0, // not supported
-    ObjMode  = 1,
-    GenMode  = 2,
-    LimMode  = 3,
-} LoadMode;
-
 static VALUE
 load(char *xml, int argc, VALUE *argv, VALUE self) {
-    VALUE       obj;
-    int         mode = AutoMode;
-    int         effort = StrictEffort;
-    int         trace = 0;
+    VALUE               obj;
+    struct _Options     options = default_options;
     
     if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
         VALUE   h = *argv;
         VALUE   v;
         
         if (Qnil != (v = rb_hash_lookup(h, mode_sym))) {
-            if (auto_sym == v) {
-                mode = AutoMode;
-            } else if (object_sym == v) {
-                mode = ObjMode;
+            if (object_sym == v) {
+                options.mode = ObjMode;
             } else if (optimized_sym == v) {
-                mode = ObjMode;
+                options.mode = ObjMode;
             } else if (generic_sym == v) {
-                mode = GenMode;
+                options.mode = GenMode;
             } else if (limited_sym == v) {
-                mode = LimMode;
+                options.mode = LimMode;
             } else {
                 rb_raise(rb_eArgError, ":mode must be :generic, :object, or :limited.\n");
             }
         }
         if (Qnil != (v = rb_hash_lookup(h, effort_sym))) {
             if (auto_define_sym == v) {
-                effort = AutoEffort;
+                options.effort = AutoEffort;
             } else if (tolerant_sym == v) {
-                effort = TolerantEffort;
+                options.effort = TolerantEffort;
             } else if (strict_sym == v) {
-                effort = StrictEffort;
+                options.effort = StrictEffort;
             } else {
                 rb_raise(rb_eArgError, ":effort must be :strict, :tolerant, or :auto_define.\n");
             }
         }
         if (Qnil != (v = rb_hash_lookup(h, trace_sym))) {
             Check_Type(v, T_FIXNUM);
-            trace = FIX2INT(v);
+            options.trace = FIX2INT(v);
         }
     }
-    switch (mode) {
+    switch (options.mode) {
     case ObjMode:
-        obj = parse(xml, ox_obj_callbacks, 0, trace, effort);
+        obj = parse(xml, ox_obj_callbacks, 0, options.trace, options.effort);
         break;
     case GenMode:
-        obj = parse(xml, ox_gen_callbacks, 0, trace, StrictEffort);
+        obj = parse(xml, ox_gen_callbacks, 0, options.trace, StrictEffort);
         break;
     case LimMode:
-        obj = parse(xml, ox_limited_callbacks, 0, trace, effort);
+        obj = parse(xml, ox_limited_callbacks, 0, options.trace, StrictEffort);
+        break;
+    case NoMode:
+        obj = parse(xml, ox_nomode_callbacks, 0, options.trace, options.effort);
         break;
-    case AutoMode:
     default:
-        obj = parse(xml, ox_gen_callbacks, 0, trace, StrictEffort);
+        obj = parse(xml, ox_gen_callbacks, 0, options.trace, StrictEffort);
         break;
     }
     free(xml);
@@ -283,36 +425,49 @@ load_file(int argc, VALUE *argv, VALUE self) {
 }
 
 static void
-parse_dump_options(VALUE options, int *indent, int *xsd_date, int *circular) {
-    if (rb_cHash == rb_obj_class(options)) {
+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(options, indent_sym))) {
+        if (Qnil != (v = rb_hash_lookup(ropts, indent_sym))) {
             if (rb_cFixnum != rb_obj_class(v)) {
                 rb_raise(rb_eArgError, ":indent must be a Fixnum.\n");
             }
-            *indent = NUM2INT(v);
+            copts->indent = NUM2INT(v);
         }
-        if (Qnil != (v = rb_hash_lookup(options, xsd_date_sym))) {
-            VALUE       c = rb_obj_class(v);
-            
-            if (rb_cTrueClass == c) {
-                *xsd_date = 1;
-            } else if (rb_cFalseClass == c) {
-                *xsd_date = 0;
-            } else {
-                rb_raise(rb_eArgError, ":xsd_date must be true or false.\n");
+        if (Qnil != (v = rb_hash_lookup(ropts, trace_sym))) {
+            if (rb_cFixnum != rb_obj_class(v)) {
+                rb_raise(rb_eArgError, ":trace must be a Fixnum.\n");
             }
+            copts->trace = NUM2INT(v);
         }
-        if (Qnil != (v = rb_hash_lookup(options, circular_sym))) {
-            VALUE       c = rb_obj_class(v);
-            
-            if (rb_cTrueClass == c) {
-                *circular = 1;
-            } else if (rb_cFalseClass == c) {
-                *circular = 0;
-            } else {
-                rb_raise(rb_eArgError, ":circular must be true or false.\n");
+        if (Qnil != (v = rb_hash_lookup(ropts, encoding_sym))) {
+            if (rb_cString != rb_obj_class(v)) {
+                rb_raise(rb_eArgError, ":encoding must be a String.\n");
+            }
+            strncpy(copts->encoding, StringValuePtr(v), sizeof(copts->encoding) - 1);
+        }
+        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(rb_eArgError, "%s must be true or false.\n", StringValuePtr(o->sym));
+                }
             }
         }
     }
@@ -329,16 +484,14 @@ parse_dump_options(VALUE options, int *indent, int *xsd_date, int *circular) {
  */
 static VALUE
 dump(int argc, VALUE *argv, VALUE self) {
-    char        *xml;
-    int         indent = 2;
-    int         xsd_date = 0;
-    int         circular = 0;
-    VALUE       rstr;
+    char                *xml;
+    struct _Options     copts;
+    VALUE               rstr;
     
     if (2 == argc) {
-        parse_dump_options(argv[1], &indent, &xsd_date, &circular);
+        parse_dump_options(argv[1], &copts);
     }
-    if (0 == (xml = write_obj_to_str(*argv, indent, xsd_date, circular))) {
+    if (0 == (xml = write_obj_to_str(*argv, &copts))) {
         rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(xml);
@@ -359,15 +512,13 @@ dump(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE
 to_file(int argc, VALUE *argv, VALUE self) {
-    int         indent = 2;
-    int         xsd_date = 0;
-    int         circular = 0;
+    struct _Options     copts;
     
     if (3 == argc) {
-        parse_dump_options(argv[2], &indent, &xsd_date, &circular);
+        parse_dump_options(argv[2], &copts);
     }
     Check_Type(*argv, T_STRING);
-    write_obj_to_file(argv[1], StringValuePtr(*argv), indent, xsd_date, circular);
+    write_obj_to_file(argv[1], StringValuePtr(*argv), &copts);
 
     return Qnil;
 }
@@ -389,7 +540,14 @@ cache8_test(VALUE self) {
 }
 
 void Init_ox() {
+    VALUE       keep = Qnil;
+
     Ox = rb_define_module("Ox");
+    keep = rb_cv_get(Ox, "@@keep"); // needed to stop GC from deleting and reusing VALUEs
+
+    rb_define_module_function(Ox, "default_options", get_def_opts, 0);
+    rb_define_module_function(Ox, "default_options=", set_def_opts, 1);
+
     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);
@@ -422,26 +580,31 @@ void Init_ox() {
     time_class = rb_const_get(rb_cObject, rb_intern("Time"));
     struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
 
-    version_sym = ID2SYM(rb_intern("version"));
-    standalone_sym = ID2SYM(rb_intern("standalone"));
-    encoding_sym = ID2SYM(rb_intern("encoding"));
-    indent_sym = ID2SYM(rb_intern("indent"));
-    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));
-    opt_format_sym = ID2SYM(rb_intern("opt_format"));
-    mode_sym = ID2SYM(rb_intern("mode"));
-    auto_sym = ID2SYM(rb_intern("auto"));
-    optimized_sym = ID2SYM(rb_intern("optimized"));
-    object_sym = ID2SYM(rb_intern("object"));
-    circular_sym = ID2SYM(rb_intern("circular"));
-    generic_sym = ID2SYM(rb_intern("generic"));
-    limited_sym = ID2SYM(rb_intern("limited"));
-    trace_sym = ID2SYM(rb_intern("trace"));
-    effort_sym = ID2SYM(rb_intern("effort"));
-    strict_sym = ID2SYM(rb_intern("strict"));
-    tolerant_sym = ID2SYM(rb_intern("tolerant"));
-    auto_define_sym = ID2SYM(rb_intern("auto_define"));
-    empty_string = rb_str_new2("");
-    zero_fixnum = INT2NUM(0);
+    version_sym = ID2SYM(rb_intern("version"));                 rb_ary_push(keep, version_sym);
+    standalone_sym = ID2SYM(rb_intern("standalone"));           rb_ary_push(keep, standalone_sym);
+    encoding_sym = ID2SYM(rb_intern("encoding"));               rb_ary_push(keep, encoding_sym);
+    indent_sym = ID2SYM(rb_intern("indent"));                   rb_ary_push(keep, indent_sym);
+    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));               rb_ary_push(keep, xsd_date_sym);
+    opt_format_sym = ID2SYM(rb_intern("opt_format"));           rb_ary_push(keep, opt_format_sym);
+    mode_sym = ID2SYM(rb_intern("mode"));                       rb_ary_push(keep, mode_sym);
+    auto_sym = ID2SYM(rb_intern("auto"));                       rb_ary_push(keep, auto_sym);
+    optimized_sym = ID2SYM(rb_intern("optimized"));             rb_ary_push(keep, optimized_sym);
+    object_sym = ID2SYM(rb_intern("object"));                   rb_ary_push(keep, object_sym);
+    circular_sym = ID2SYM(rb_intern("circular"));               rb_ary_push(keep, circular_sym);
+    generic_sym = ID2SYM(rb_intern("generic"));                 rb_ary_push(keep, generic_sym);
+    limited_sym = ID2SYM(rb_intern("limited"));                 rb_ary_push(keep, limited_sym);
+    trace_sym = ID2SYM(rb_intern("trace"));                     rb_ary_push(keep, trace_sym);
+    effort_sym = ID2SYM(rb_intern("effort"));                   rb_ary_push(keep, effort_sym);
+    strict_sym = ID2SYM(rb_intern("strict"));                   rb_ary_push(keep, strict_sym);
+    tolerant_sym = ID2SYM(rb_intern("tolerant"));               rb_ary_push(keep, tolerant_sym);
+    auto_define_sym = ID2SYM(rb_intern("auto_define"));         rb_ary_push(keep, auto_define_sym);
+    with_dtd_sym = ID2SYM(rb_intern("with_dtd"));               rb_ary_push(keep, with_dtd_sym);
+    with_instruct_sym = ID2SYM(rb_intern("with_instructions")); rb_ary_push(keep, with_instruct_sym);
+    with_xml_sym = ID2SYM(rb_intern("with_xml"));               rb_ary_push(keep, with_xml_sym);
+
+    empty_string = rb_str_new2("");                             rb_ary_push(keep, empty_string);
+    zero_fixnum = INT2NUM(0);                                   rb_ary_push(keep, zero_fixnum);
+
     
     //rb_require("node"); // generic xml node classes
     ox_document_clas = rb_const_get(Ox, rb_intern("Document"));