ox 2.11.0 → 2.13.3

data/ext/ox/ox.c

@@ -127,6 +127,7 @@ 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;
@@ -153,10 +154,8 @@ static VALUE 	element_key_mod_sym;
 static ID	encoding_id;
 static ID	has_key_id;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 rb_encoding	*ox_utf8_encoding = 0;
-#elif HAS_PRIVATE_ENCODING
-VALUE		ox_utf8_encoding = Qnil;
 #else
 void		*ox_utf8_encoding = 0;
 #endif
@@ -177,18 +176,15 @@ struct _options	 ox_default_options = {
     Yes,		// sym_keys
     SpcSkip,		// skip
     No,			// smart
-    1,			// convert_special
+    true,		// convert_special
     No,			// allow_invalid
+    false,		// no_empty
     { '\0' },		// inv_repl
     { '\0' },		// strip_ns
     NULL,		// html_hints
     Qnil,		// attr_key_mod;
     Qnil,		// element_key_mod;
-#if HAS_PRIVATE_ENCODING
-    Qnil		// rb_enc
-#else
     0			// rb_enc
-#endif
 };
 
 extern ParseCallbacks	ox_obj_callbacks;
@@ -293,6 +289,7 @@ hints_to_overlay(Hints hints) {
  * - _: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 < 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
  * - _: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
@@ -326,6 +323,7 @@ get_def_opts(VALUE self) {
     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);
     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;
@@ -466,11 +464,8 @@ set_def_opts(VALUE self, VALUE opts) {
     } else {
 	Check_Type(v, T_STRING);
 	strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
 	ox_default_options.rb_enc = rb_enc_find(ox_default_options.encoding);
-#elif HAS_PRIVATE_ENCODING
-	ox_default_options.rb_enc = rb_str_new2(ox_default_options.encoding);
-	rb_gc_register_address(&ox_default_options.rb_enc);
 #endif
     }
 
@@ -542,6 +537,17 @@ set_def_opts(VALUE self, VALUE opts) {
 	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;
@@ -659,14 +665,14 @@ to_obj(VALUE self, VALUE ruby_xml) {
 	xml = ALLOCA_N(char, len);
     }
     memcpy(xml, x, len);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_disable();
 #endif
     obj = ox_parse(xml, len - 1, ox_obj_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     RB_GC_GUARD(obj);
     rb_gc_enable();
 #endif
@@ -777,6 +783,9 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
 	if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
 	    options.convert_special = (Qfalse != v);
 	}
+	if (Qnil != (v = rb_hash_lookup(h, no_empty_sym))) {
+	    options.no_empty = (Qfalse != v);
+	}
 
 	v = rb_hash_lookup(h, invalid_replace_sym);
 	if (Qnil == v) {
@@ -830,7 +839,7 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
 	    options.margin_len = strlen(options.margin);
 	}
     }
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     if ('\0' == *options.encoding) {
 	if (Qnil != encoding) {
 	    options.rb_enc = rb_enc_from_index(rb_enc_get_index(encoding));
@@ -840,26 +849,15 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
     } else if (0 == options.rb_enc) {
 	options.rb_enc = rb_enc_find(options.encoding);
     }
-#elif HAS_PRIVATE_ENCODING
-    if ('\0' == *options.encoding) {
-	if (Qnil != encoding) {
-	    options.rb_enc = encoding;
-	} else {
-	    options.rb_enc = Qnil;
-	}
-    } else if (0 == options.rb_enc) {
-	options.rb_enc = rb_str_new2(options.encoding);
-	rb_gc_register_address(&options.rb_enc);
-    }
 #endif
     xml = defuse_bom(xml, &options);
     switch (options.mode) {
     case ObjMode:
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	rb_gc_disable();
 #endif
 	obj = ox_parse(xml, len, ox_obj_callbacks, 0, &options, err);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	RB_GC_GUARD(obj);
 	rb_gc_enable();
 #endif
@@ -928,14 +926,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
     } else {
 	xml = ALLOCA_N(char, len);
     }
-#if HAS_ENCODING_SUPPORT
-#ifdef MACRUBY_RUBY
-    encoding = rb_funcall(*argv, encoding_id, 0);
-#else
+#if HAVE_RB_OBJ_ENCODING
     encoding = rb_obj_encoding(*argv);
-#endif
-#elif HAS_PRIVATE_ENCODING
-    encoding = rb_funcall(*argv, encoding_id, 0);
 #else
     encoding = Qnil;
 #endif
@@ -996,7 +988,7 @@ load_file(int argc, VALUE *argv, VALUE self) {
 	xml = ALLOCA_N(char, len + 1);
     }
     fseek(f, 0, SEEK_SET);
-    if (len != fread(xml, 1, len, f)) {
+    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 {
@@ -1208,6 +1200,9 @@ parse_dump_options(VALUE ropts, Options copts) {
 	    }
 	    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;
@@ -1275,6 +1270,7 @@ parse_dump_options(VALUE ropts, Options copts) {
  * - +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
@@ -1297,21 +1293,38 @@ dump(int argc, VALUE *argv, VALUE self) {
 	rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(xml);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     if ('\0' != *copts.encoding) {
 	rb_enc_associate(rstr, rb_enc_find(copts.encoding));
     }
-#elif HAS_PRIVATE_ENCODING
-    if ('\0' != *copts.encoding) {
-	rb_funcall(rstr, ox_force_encoding_id, 1, rb_str_new2(copts.encoding));
-    }
 #endif
     xfree(xml);
 
     return rstr;
 }
 
-/* call-seq: to_file(file_path, obj, options)
+/* call-seq: to_xml(obj, options) => xml-string
+ *
+ * Dumps an Object (obj) to a string.
+ * - +obj+ [Object] Object to serialize as an XML document String
+ * - +options+ [Hash] formating options
+ *   - *:indent* [Fixnum] format expected
+ *   - *:no_empty* [true|false] if true don't output empty elements
+ *   - *:xsd_date* [true|false] use XSD date format if true, default: false
+ *   - *:circular* [true|false] allow circular references, default: false
+ *   - *:strict|:tolerant]* [ :effort effort to use when an undumpable object (e.g., IO) is encountered, default: :strict
+ *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
+ *     - _:tolerant_ - replaces undumplable objects with nil
+ *
+ * Note that an indent of less than zero will result in a tight one line output
+ * unless the text in the XML fields contain new line characters.
+ */
+static VALUE
+to_xml(int argc, VALUE *argv, VALUE self) {
+    return dump(argc, argv, self);
+}
+
+/* call-seq: to_file(file_path, obj, options) => Object
  *
  * Dumps an Object to the specified file.
  * - +file_path+ [String] file path to write the XML document to
@@ -1370,7 +1383,7 @@ void Init_ox() {
     rb_define_module_function(Ox, "sax_parse", sax_parse, -1);
     rb_define_module_function(Ox, "sax_html", sax_html, -1);
 
-    rb_define_module_function(Ox, "to_xml", dump, -1);
+    rb_define_module_function(Ox, "to_xml", to_xml, -1);
     rb_define_module_function(Ox, "dump", dump, -1);
 
     rb_define_module_function(Ox, "load_file", load_file, -1);
@@ -1480,6 +1493,7 @@ void Init_ox() {
     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);
@@ -1532,11 +1546,8 @@ void Init_ox() {
     rb_define _module_function(Ox, "cache8_test", cache8_test, 0);
 #endif
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     ox_utf8_encoding = rb_enc_find("UTF-8");
-#elif HAS_PRIVATE_ENCODING
-    ox_utf8_encoding = rb_str_new2("UTF-8");
-    rb_gc_register_address(&ox_utf8_encoding);
 #endif
 }
 
@@ -1557,7 +1568,7 @@ _ox_raise_error(const char *msg, const char *xml, const char *current, const cha
 	    xline++;
 	}
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_enable();
 #endif
     rb_raise(ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);

data/ext/ox/ox.h

@@ -16,20 +16,15 @@ extern "C" {
 #define RSTRING_NOT_MODIFIED
 
 #include "ruby.h"
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 #include "ruby/encoding.h"
 #endif
 
-#ifdef RUBINIUS_RUBY
-#undef T_COMPLEX
-enum st_retval {ST_CONTINUE = 0, ST_STOP = 1, ST_DELETE = 2, ST_CHECK};
+#if HAVE_RUBY_ST_H
+#include "ruby/st.h"
 #else
-#if HAS_TOP_LEVEL_ST_H
-/* Only on travis, local is where it is for all others. Seems to vary depending on the travis machine picked up. */
+// Only on travis, local is where it is for all others. Seems to vary depending on the travis machine picked up.
 #include "st.h"
-#else
-#include "ruby/st.h"
-#endif
 #endif
 
 #include "cache.h"
@@ -123,49 +118,51 @@ typedef struct _circArray {
 } *CircArray;
 
 typedef struct _options {
-    char		encoding[64];	/* encoding, stored in the option to avoid GC invalidation in default values */
-    char		margin[128];	/* left margin for dumping */
-    int			indent;		/* indention for dump, default 2 */
-    int			trace;		/* trace level */
-    char		margin_len;	/* margin length */
-    char		with_dtd;	/* YesNo */
-    char		with_xml;	/* YesNo */
-    char		with_instruct;	/* YesNo */
-    char		circular;	/* YesNo */
-    char		xsd_date;	/* YesNo */
-    char		mode;		/* LoadMode */
-    char		effort;		/* Effort */
-    char		sym_keys;	/* symbolize keys */
-    char		skip;		/* skip mode */
-    char		smart;		/* YesNo sax smart mode */
-    char		convert_special;/* boolean true or false */
-    char		allow_invalid;	/* YesNo */
-    char		inv_repl[12];	/* max 10 valid characters, first character is the length */
-    char		strip_ns[64];	/* namespace to strip, \0 is no-strip, \* is all, else only matches */
-    struct _hints	*html_hints;	/* html hints */
+    char		encoding[64];	// encoding, stored in the option to avoid GC invalidation in default values
+    char		margin[128];	// left margin for dumping
+    int			indent;		// indention for dump, default 2
+    int			trace;		// trace level
+    char		margin_len;	// margin length
+    char		with_dtd;	// YesNo
+    char		with_xml;	// YesNo
+    char		with_instruct;	// YesNo
+    char		circular;	// YesNo
+    char		xsd_date;	// YesNo
+    char		mode;		// LoadMode
+    char		effort;		// Effort
+    char		sym_keys;	// symbolize keys
+    char		skip;		// skip mode
+    char		smart;		// YesNo sax smart mode
+    char		convert_special;// boolean true or false
+    char		allow_invalid;	// YesNo
+    char		no_empty;	// boolean - no empty elements when dumping
+    char		inv_repl[12];	// max 10 valid characters, first character is the length
+    char		strip_ns[64];	// namespace to strip, \0 is no-strip, \* is all, else only matches
+    struct _hints	*html_hints;	// html hints
     VALUE		attr_key_mod;
     VALUE		element_key_mod;
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     rb_encoding		*rb_enc;
-#elif HAS_PRIVATE_ENCODING
-    VALUE		rb_enc;
 #else
     void		*rb_enc;
 #endif
 } *Options;
 
-/* parse information structure */
+// parse information structure
 struct _pInfo {
     struct _helperStack	helpers;
     struct _err		err;
-    char		*str;		//buffer being read from
+    char		*str;		// buffer being read from
     char		*end;		// end of original string
     char		*s;		// current position in buffer
     VALUE		obj;
     ParseCallbacks	pcb;
     CircArray		circ_array;
-    unsigned long	id;		//set for text types when cirs_array is set
+    unsigned long	id;		// set for text types when cirs_array is set
     Options		options;
+    VALUE		*marked;
+    int			mark_size;	// allocated size
+    int			mark_cnt;
     char		last;		// last character read, rarely set
 };
 
@@ -232,10 +229,8 @@ extern ID	ox_tv_nsec_id;
 extern ID	ox_tv_usec_id;
 extern ID	ox_value_id;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 extern rb_encoding	*ox_utf8_encoding;
-#elif HAS_PRIVATE_ENCODING
-extern VALUE		ox_utf8_encoding;
 #else
 extern void		*ox_utf8_encoding;
 #endif

data/ext/ox/parse.c

@@ -121,7 +121,7 @@ ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options
     if (DEBUG <= options->trace) {
 	printf("Parsing xml:\n%s\n", xml);
     }
-    /* initialize parse info */
+    // initialize parse info
     helper_stack_init(&pi.helpers);
     // Protect against GC
     wrap = Data_Wrap_Struct(rb_cObject, mark_pi_cb, NULL, &pi);
@@ -134,8 +134,11 @@ ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options
     pi.obj = Qnil;
     pi.circ_array = 0;
     pi.options = options;
+    pi.marked = NULL;
+    pi.mark_size = 0;
+    pi.mark_cnt = 0;
     while (1) {
-	next_non_white(&pi);	/* skip white space */
+	next_non_white(&pi);	// skip white space
 	if ('\0' == *pi.s) {
 	    break;
 	}
@@ -143,31 +146,31 @@ ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options
 	    *endp = pi.s;
 	    break;
 	}
-	if ('<' != *pi.s) {		/* all top level entities start with < */
+	if ('<' != *pi.s) {		// all top level entities start with <
 	    set_error(err, "invalid format, expected <", pi.str, pi.s);
 	    helper_stack_cleanup(&pi.helpers);
 	    return Qnil;
 	}
-	pi.s++;		/* past < */
+	pi.s++;		// past <
 	switch (*pi.s) {
-	case '?':	/* processing instruction */
+	case '?':	// processing instruction
 	    pi.s++;
 	    read_instruction(&pi);
 	    break;
-	case '!':	/* comment or doctype */
+	case '!':	// comment or doctype
 	    pi.s++;
 	    if ('\0' == *pi.s) {
 		set_error(err, "invalid format, DOCTYPE or comment not terminated", pi.str, pi.s);
 		helper_stack_cleanup(&pi.helpers);
 		return Qnil;
 	    } else if ('-' == *pi.s) {
-		pi.s++;	/* skip - */
+		pi.s++;	// skip -
 		if ('-' != *pi.s) {
 		    set_error(err, "invalid format, bad comment format", pi.str, pi.s);
 		    helper_stack_cleanup(&pi.helpers);
 		    return Qnil;
 		} else {
-		    pi.s++;	/* skip second - */
+		    pi.s++;	// skip second -
 		    read_comment(&pi);
 		}
 	    } else if ((TolerantEffort == options->effort) ? 0 == strncasecmp("DOCTYPE", pi.s, 7) : 0 == strncmp("DOCTYPE", pi.s, 7)) {
@@ -229,8 +232,7 @@ gather_content(const char *src, char *content, size_t len) {
     return 0;
 }
 
-/* Entered after the "<?" sequence. Ready to read the rest.
- */
+// Entered after the "<?" sequence. Ready to read the rest.
 static void
 read_instruction(PInfo pi) {
     char		content[1024];
@@ -255,7 +257,7 @@ read_instruction(PInfo pi) {
     }
     next_non_white(pi);
     c = *pi->s;
-    *end = '\0'; /* terminate name */
+    *end = '\0'; // terminate name
     if ('?' != c) {
 	while ('?' != c) {
 	    pi->last = 0;
@@ -275,8 +277,8 @@ read_instruction(PInfo pi) {
 		attrs_ok = 0;
 		break;
 	    }
-	    *end = '\0'; /* terminate name */
-	    /* read value */
+	    *end = '\0'; // terminate name
+	    // read value
 	    next_non_white(pi);
 	    if (0 == (attr_value = read_quoted_value(pi))) {
 		attr_stack_cleanup(&attrs);
@@ -355,9 +357,8 @@ read_delimited(PInfo pi, char end) {
     }
 }
 
-/* Entered after the "<!DOCTYPE" sequence plus the first character after
- * that. Ready to read the rest.
- */
+// Entered after the "<!DOCTYPE" sequence plus the first character after
+// that. Ready to read the rest.
 static void
 read_doctype(PInfo pi) {
     char	*docType;
@@ -376,8 +377,7 @@ read_doctype(PInfo pi) {
     }
 }
 
-/* Entered after "<!--". Returns error code.
- */
+// Entered after "<!--". Returns error code.
 static void
 read_comment(PInfo pi) {
     char	*end;
@@ -406,16 +406,15 @@ read_comment(PInfo pi) {
 	    break;
 	}
     }
-    *end = '\0'; /* in case the comment was blank */
+    *end = '\0'; // in case the comment was blank
     pi->s = end + 3;
     if (0 != pi->pcb->add_comment) {
 	pi->pcb->add_comment(pi, comment);
     }
 }
 
-/* Entered after the '<' and the first character after that. Returns status
- * code.
- */
+// Entered after the '<' and the first character after that. Returns stat
+// code.
 static char*
 read_element(PInfo pi) {
     struct _attrStack	attrs;
@@ -439,10 +438,9 @@ read_element(PInfo pi) {
     c = *pi->s;
     *end = '\0';
     if ('/' == c) {
-	/* empty element, no attributes and no children */
+	// empty element, no attributes and no children
 	pi->s++;
 	if ('>' != *pi->s) {
-	    /*printf("*** '%s' ***\n", pi->s); */
 	    attr_stack_cleanup(&attrs);
 	    set_error(&pi->err, "invalid format, element not closed", pi->str, pi->s);
 	    return 0;
@@ -480,8 +478,8 @@ read_element(PInfo pi) {
 	    pi->s++;
 	    pi->pcb->add_element(pi, ename, attrs.head, hasChildren);
 	    pi->pcb->end_element(pi, ename);
-
 	    attr_stack_cleanup(&attrs);
+
 	    return 0;
 	case '>':
 	    /* has either children or a value */
@@ -545,6 +543,12 @@ read_element(PInfo pi) {
 	while (!done) {
 	    start = pi->s;
 	    next_non_white(pi);
+	    if (OffSkip == pi->options->skip && start < pi->s && '<' == *pi->s) {
+		c = *pi->s;
+		*pi->s = '\0';
+		pi->pcb->add_text(pi, start, 1);
+		*pi->s = c;
+	    }
 	    c = *pi->s++;
 	    if ('\0' == c) {
 		attr_stack_cleanup(&attrs);
@@ -1001,11 +1005,13 @@ read_coded_chars(PInfo pi, char *text) {
     char	*b, buf[32];
     char	*end = buf + sizeof(buf) - 1;
     char	*s;
+    long	blen = 0;
 
     for (b = buf, s = pi->s; b < end; b++, s++) {
 	*b = *s;
 	if (';' == *s) {
 	    *(b + 1) = '\0';
+	    blen = b - buf;
 	    s++;
 	    break;
 	}
@@ -1026,18 +1032,9 @@ read_coded_chars(PInfo pi, char *text) {
 	} else {
 	    if (u <= 0x000000000000007FULL) {
 		*text++ = (char)u;
-#if HAS_PRIVATE_ENCODING
-	    } else if (ox_utf8_encoding == pi->options->rb_enc ||
-		       0 == strcasecmp(rb_str_ptr(rb_String(ox_utf8_encoding)), rb_str_ptr(rb_String(pi->options->rb_enc)))) {
-#else
 	    } else if (ox_utf8_encoding == pi->options->rb_enc) {
-#endif
 		text = ox_ucs_to_utf8_chars(text, u);
-#if HAS_PRIVATE_ENCODING
-	    } else if (Qnil == pi->options->rb_enc) {
-#else
 	    } else if (0 == pi->options->rb_enc) {
-#endif
 		pi->options->rb_enc = ox_utf8_encoding;
 		text = ox_ucs_to_utf8_chars(text, u);
 	    } else if (TolerantEffort == pi->options->effort) {
@@ -1048,30 +1045,20 @@ read_coded_chars(PInfo pi, char *text) {
 	    } else {
 		/*set_error(&pi->err, "Invalid encoding, need UTF-8 or UTF-16 encoding to parse &#nnnn; character sequences.", pi->str, pi->s); */
 		set_error(&pi->err, "Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences.", pi->str, pi->s);
-		return 0;
+		return NULL;
 	    }
 	    pi->s = s;
 	}
-    } else if (0 == strcasecmp(buf, "nbsp;")) {
-	pi->s = s;
-	*text++ = ' ';
-    } else if (0 == strcasecmp(buf, "lt;")) {
-	pi->s = s;
-	*text++ = '<';
-    } else if (0 == strcasecmp(buf, "gt;")) {
-	pi->s = s;
-	*text++ = '>';
-    } else if (0 == strcasecmp(buf, "amp;")) {
-	pi->s = s;
-	*text++ = '&';
-    } else if (0 == strcasecmp(buf, "quot;")) {
-	pi->s = s;
-	*text++ = '"';
-    } else if (0 == strcasecmp(buf, "apos;")) {
-	pi->s = s;
-	*text++ = '\'';
     } else {
-	*text++ = '&';
+	char	*t2;
+
+	buf[blen] = '\0';
+	if (NULL == (t2 = ox_entity_lookup(text, buf))) {
+	    *text++ = '&';
+	} else {
+	    text = t2;
+	    pi->s = s;
+	}
     }
     return text;
 }
@@ -1113,19 +1100,10 @@ collapse_special(PInfo pi, char *str) {
 		}
 		if (u <= 0x000000000000007FULL) {
 		    *b++ = (char)u;
-#if HAS_PRIVATE_ENCODING
-		} else if (ox_utf8_encoding == pi->options->rb_enc ||
-			   0 == strcasecmp(rb_str_ptr(rb_String(ox_utf8_encoding)), rb_str_ptr(rb_String(pi->options->rb_enc)))) {
-#else
 		} else if (ox_utf8_encoding == pi->options->rb_enc) {
-#endif
 		    b = ox_ucs_to_utf8_chars(b, u);
 		    /* TBD support UTF-16 */
-#if HAS_PRIVATE_ENCODING
-		} else if (Qnil == pi->options->rb_enc) {
-#else
 		} else if (0 == pi->options->rb_enc) {
-#endif
 		    pi->options->rb_enc = ox_utf8_encoding;
 		    b = ox_ucs_to_utf8_chars(b, u);
 		} else {
@@ -1154,16 +1132,30 @@ collapse_special(PInfo pi, char *str) {
 		    *b++ = '&';
 		    continue;
 		} else {
-		    c = '?';
+		    char	key[16];
+		    char	*k = key;
+		    char	*kend = key + sizeof(key) - 1;
+
+		    *k++ = *s;
 		    while (';' != *s++) {
 			if ('\0' == *s) {
 			    set_error(&pi->err, "Invalid format, special character does not end with a semicolon", pi->str, pi->s);
 			    return EDOM;
 			}
+			if (kend <= k) {
+			    k = key;
+			    break;
+			}
+			*k++ = *s;
 		    }
-		    s++;
-		    set_error(&pi->err, "Invalid format, invalid special character sequence", pi->str, pi->s);
-		    return 0;
+		    k--;
+		    *k = '\0';
+		    if ('\0' == *key || NULL == (b = ox_entity_lookup(b, key))) {
+			set_error(&pi->err, "Invalid format, invalid special character sequence", pi->str, pi->s);
+			c = '?';
+			return 0;
+		    }
+		    continue;
 		}
 		*b++ = (char)c;
 	    }