ox 1.4.6 → 1.5.0

data/README.md

@@ -24,11 +24,17 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 [Fast Ruby XML Serialization](http://www.ohler.com/software/thoughts/Blog/Entries/2011/9/20_Ruby_Object_XML_Serialization.html) to see how Ox can be used as a faster replacement for Marshal.
 
+*Fast JSON parser and marshaller on RubyGems*: https://rubygems.org/gems/oj
+
+*Fast JSON parser and marshaller on GitHub*: https://rubygems.org/gems/oj
+
 ## <a name="release">Release Notes</a>
 
-### Release 1.4.6
+### Release 1.5.0
+
+ - Changed to use escape sequences in XML instead of using B64 encoding. B64 encoding type is still supported on read.
 
- - Adopted the Exception message encoding hack to work for the latests ruby versions.
+ - Prefixed extern C functions with ox_ to avoid conflicts.
 
 ## <a name="description">Description</a>
 

data/ext/ox/dump.c

@@ -44,6 +44,8 @@
 #include "cache8.h"
 #include "ox.h"
 
+#define USE_B64	0
+
 typedef unsigned long   ulong;
 
 typedef struct _Str {
@@ -93,6 +95,7 @@ static void     dump_end(Out out, Element e);
 static void     grow(Out out, size_t len);
 
 static void     dump_value(Out out, const char *value, size_t size);
+static void     dump_str_value(Out out, const char *value, size_t size);
 static int      dump_var(ID key, VALUE value, Out out);
 static void     dump_num(Out out, VALUE obj);
 static void     dump_time_thin(Out out, VALUE obj);
@@ -101,27 +104,47 @@ static int      dump_hash(VALUE key, VALUE value, Out out);
 
 static int      is_xml_friendly(const u_char *str, int len);
 
+static const char	hex_chars[17] = "0123456789abcdef";
 
 static char     xml_friendly_chars[256] = "\
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\
-ooxoooxxooooooooooooooooooooxoxo\
-oooooooooooooooooooooooooooooooo\
-xoooooooooooooooooooooooooooooox\
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+88888888811881888888888888888888\
+11611156111111111111111111114141\
+11111111111111111111111111111111\
+1111111111111111111111111111111x\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111";
 
 inline static int
 is_xml_friendly(const u_char *str, int len) {
     for (; 0 < len; str++, len--) {
-        if ('x' == xml_friendly_chars[*str]) {
+        if ('1' != xml_friendly_chars[*str]) {
             return 0;
         }
     }
     return 1;
 }
 
+inline static size_t
+xml_str_len(const u_char *str, size_t len) {
+    size_t	size = 0;
+
+    for (; 0 < len; str++, len--) {
+	size += xml_friendly_chars[*str];
+    }
+    return size - len * (size_t)'0';
+}
+
+inline static void
+dump_hex(u_char c, Out out) {
+    u_char	d = (c >> 4) & 0x0F;
+
+    *out->cur++ = hex_chars[d];
+    d = c & 0x0F;
+    *out->cur++ = hex_chars[d];
+}
+
 inline static Type
 obj_class_code(VALUE obj) {
     switch (rb_type(obj)) {
@@ -319,6 +342,59 @@ dump_value(Out out, const char *value, size_t size) {
     *out->cur = '\0';
 }
 
+inline static void
+dump_str_value(Out out, const char *value, size_t size) {
+    size_t	xsize = xml_str_len((const u_char*)value, size);
+
+    if (out->end - out->cur <= (long)xsize) {
+        grow(out, xsize);
+    }
+    for (; '\0' != *value; value++) {
+	if ('1' == xml_friendly_chars[(u_char)*value]) {
+	    *out->cur++ = *value;
+	} else {
+	    *out->cur++ = '&';
+	    switch (*value) {
+	    case '"':
+		*out->cur++ = 'q';
+		*out->cur++ = 'u';
+		*out->cur++ = 'o';
+		*out->cur++ = 't';
+		break;
+	    case '&':
+		*out->cur++ = 'a';
+		*out->cur++ = 'm';
+		*out->cur++ = 'p';
+		break;
+	    case '\'':
+		*out->cur++ = 'a';
+		*out->cur++ = 'p';
+		*out->cur++ = 'o';
+		*out->cur++ = 's';
+		break;
+	    case '<':
+		*out->cur++ = 'l';
+		*out->cur++ = 't';
+		break;
+	    case '>':
+		*out->cur++ = 'g';
+		*out->cur++ = 't';
+		break;
+	    default:
+		*out->cur++ = '&';
+		*out->cur++ = '#';
+		*out->cur++ = 'x';
+		*out->cur++ = '0';
+		*out->cur++ = '0';
+		dump_hex(*value, out);
+		break;
+	    }
+	    *out->cur++ = ';';
+	}
+    }
+    *out->cur = '\0';
+}
+
 inline static void
 dump_num(Out out, VALUE obj) {
     char        buf[32];
@@ -356,8 +432,8 @@ static void
 dump_time_thin(Out out, VALUE obj) {
     char        buf[64];
     char        *b = buf + sizeof(buf) - 1;
-    time_t      sec = NUM2LONG(rb_funcall2(obj, tv_sec_id, 0, 0));
-    long        usec = NUM2LONG(rb_funcall2(obj, tv_usec_id, 0, 0));
+    time_t      sec = NUM2LONG(rb_funcall2(obj, ox_tv_sec_id, 0, 0));
+    long        usec = NUM2LONG(rb_funcall2(obj, ox_tv_usec_id, 0, 0));
     char        *dot = b - 7;
     long        size;
 
@@ -381,8 +457,8 @@ dump_time_thin(Out out, VALUE obj) {
 static void
 dump_time_xsd(Out out, VALUE obj) {
     struct tm   *tm;
-    time_t      sec = NUM2LONG(rb_funcall2(obj, tv_sec_id, 0, 0));
-    long        usec = NUM2LONG(rb_funcall2(obj, tv_usec_id, 0, 0));
+    time_t      sec = NUM2LONG(rb_funcall2(obj, ox_tv_sec_id, 0, 0));
+    long        usec = NUM2LONG(rb_funcall2(obj, ox_tv_usec_id, 0, 0));
     int         tzhour, tzmin;
     char        tzsign = '+';
 
@@ -537,10 +613,11 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
         }
         str = StringValuePtr(obj);
         cnt = (int)RSTRING_LEN(obj);
+#if USE_B64
         if (is_xml_friendly((u_char*)str, cnt)) {
             e.type = StringCode;
             out->w_start(out, &e);
-            dump_value(out, str, cnt);
+            dump_str_value(out, str, cnt);
             e.indent = -1;
             out->w_end(out, &e);
         } else {
@@ -563,6 +640,13 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
                 free(b64);
             }
         }
+#else
+	e.type = StringCode;
+	out->w_start(out, &e);
+	dump_str_value(out, str, cnt);
+	e.indent = -1;
+	out->w_end(out, &e);
+#endif
         break;
     }
     case T_SYMBOL:
@@ -570,10 +654,11 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
         const char      *sym = rb_id2name(SYM2ID(obj));
 
         cnt = (int)strlen(sym);
+#if USE_B64
         if (is_xml_friendly((u_char*)sym, cnt)) {
             e.type = SymbolCode;
             out->w_start(out, &e);
-            dump_value(out, sym, cnt);
+            dump_str_value(out, sym, cnt);
             e.indent = -1;
             out->w_end(out, &e);
         } else {
@@ -596,6 +681,13 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
                 free(b64);
             }
         }
+#else
+	e.type = SymbolCode;
+	out->w_start(out, &e);
+	dump_str_value(out, sym, cnt);
+	e.indent = -1;
+	out->w_end(out, &e);
+#endif
         break;
     }
     case T_DATA:
@@ -641,9 +733,9 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
 
             e.type = RangeCode;  e.clas.len = 5;  e.clas.str = "Range";
             out->w_start(out, &e);
-            dump_obj(beg_id, beg, d2, out);
-            dump_obj(end_id, end, d2, out);
-            dump_obj(excl_id, excl, d2, out);
+            dump_obj(ox_beg_id, beg, d2, out);
+            dump_obj(ox_end_id, end, d2, out);
+            dump_obj(ox_excl_id, excl, d2, out);
             out->w_end(out, &e);
         } else {
             char        num_buf[16];
@@ -730,7 +822,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
     case T_REGEXP:
     {
 #if 1
-        VALUE           rs = rb_funcall2(obj, inspect_id, 0, 0);
+        VALUE           rs = rb_funcall2(obj, ox_inspect_id, 0, 0);
         const char      *s = StringValuePtr(rs);
 
         cnt = (int)RSTRING_LEN(rs);
@@ -742,9 +834,10 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
 #endif
         e.type = RegexpCode;
         out->w_start(out, &e);
+#if USE_B64
         if (is_xml_friendly((u_char*)s, cnt)) {
             //dump_value(out, "/", 1);
-            dump_value(out, s, cnt);
+            dump_str_value(out, s, cnt);
         } else {
             char        buf64[4096];
             char        *b64 = buf64;
@@ -761,6 +854,9 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
                 free(b64);
             }
         }
+#else
+	dump_str_value(out, s, cnt);
+#endif
 #if 0
         dump_value(out, "/", 1);
         if (0 != (ONIG_OPTION_MULTILINE & options)) {
@@ -831,7 +927,7 @@ dump_obj(ID aid, VALUE obj, unsigned int depth, Out out) {
 
 static int
 dump_var(ID key, VALUE value, Out out) {
-    if (T_DATA == rb_type(value) && key == mesg_id) {
+    if (T_DATA == rb_type(value) && key == ox_mesg_id) {
         /* There is a secret recipe that keeps Exception mesg attributes as a
          * T_DATA until it is needed. The safe way around this hack is to call
          * the message() method and use the returned string as the
@@ -839,7 +935,7 @@ dump_var(ID key, VALUE value, Out out) {
          * hack. If there are others they will have to be handled one at a
          * time.
          */
-	value = rb_funcall(out->obj, message_id, 0);
+	value = rb_funcall(out->obj, ox_message_id, 0);
     }
     dump_obj(key, value, out->depth, out);
 
@@ -856,11 +952,11 @@ dump_hash(VALUE key, VALUE value, Out out) {
 
 static void
 dump_gen_doc(VALUE obj, unsigned int depth, Out out) {
-    VALUE       attrs = rb_attr_get(obj, attributes_id);
-    VALUE       nodes = rb_attr_get(obj, nodes_id);
+    VALUE       attrs = rb_attr_get(obj, ox_attributes_id);
+    VALUE       nodes = rb_attr_get(obj, ox_nodes_id);
 
     if ('\0' == *out->opts->encoding && Qnil != attrs) {
-	VALUE	renc = rb_hash_lookup(attrs, encoding_sym);
+	VALUE	renc = rb_hash_lookup(attrs, ox_encoding_sym);
 
         if (Qnil != renc) {
 	    const char  *enc = StringValuePtr(renc);
@@ -872,7 +968,7 @@ dump_gen_doc(VALUE obj, unsigned int depth, Out out) {
         dump_value(out, "<?xml", 5);
         if (Qnil != attrs) {
             rb_hash_foreach(attrs, dump_gen_attr, (VALUE)out);
-        }
+	}
         dump_value(out, "?>", 2);
     }
     if (Yes == out->opts->with_instruct) {
@@ -889,9 +985,9 @@ dump_gen_doc(VALUE obj, unsigned int depth, Out out) {
 
 static void
 dump_gen_element(VALUE obj, unsigned int depth, Out out) {
-    VALUE       rname = rb_attr_get(obj, value_id);
-    VALUE       attrs = rb_attr_get(obj, attributes_id);
-    VALUE       nodes = rb_attr_get(obj, nodes_id);
+    VALUE       rname = rb_attr_get(obj, ox_value_id);
+    VALUE       attrs = rb_attr_get(obj, ox_attributes_id);
+    VALUE       nodes = rb_attr_get(obj, ox_nodes_id);
     const char  *name = StringValuePtr(rname);
     long        nlen = RSTRING_LEN(rname);
     size_t      size;
@@ -950,7 +1046,7 @@ dump_gen_nodes(VALUE obj, unsigned int depth, Out out) {
             if (ox_element_clas == clas) {
                 dump_gen_element(*np, d2, out);
             } else if (rb_cString == clas) {
-                dump_value(out, StringValuePtr(*np), RSTRING_LEN(*np));
+                dump_str_value(out, StringValuePtr(*np), RSTRING_LEN(*np));
                 indent_needed = (1 == cnt) ? 0 : 1;
             } else if (ox_comment_clas == clas) {
                 dump_gen_val_node(*np, d2, "<!-- ", 5, " -->", 4, out);
@@ -989,7 +1085,7 @@ static void
 dump_gen_val_node(VALUE obj, unsigned int depth,
                   const char *pre, size_t plen,
                   const char *suf, size_t slen, Out out) {
-    VALUE       v = rb_attr_get(obj, value_id);
+    VALUE       v = rb_attr_get(obj, ox_value_id);
     const char  *val;
     size_t      vlen;
     size_t      size;
@@ -1050,7 +1146,7 @@ dump_obj_to_xml(VALUE obj, Options copts, Out out) {
 }
 
 char*
-write_obj_to_str(VALUE obj, Options copts) {
+ox_write_obj_to_str(VALUE obj, Options copts) {
     struct _Out out;
     
     dump_obj_to_xml(obj, copts, &out);
@@ -1058,7 +1154,7 @@ write_obj_to_str(VALUE obj, Options copts) {
 }
 
 void
-write_obj_to_file(VALUE obj, const char *path, Options copts) {
+ox_write_obj_to_file(VALUE obj, const char *path, Options copts) {
     struct _Out out;
     size_t      size;
     FILE        *f;    

data/ext/ox/gen_load.c

@@ -94,8 +94,8 @@ create_doc(PInfo pi) {
     pi->h = pi->helpers;
     doc = rb_obj_alloc(ox_document_clas);
     nodes = rb_ary_new();
-    rb_ivar_set(doc, attributes_id, rb_hash_new());
-    rb_ivar_set(doc, nodes_id, nodes);
+    rb_ivar_set(doc, ox_attributes_id, rb_hash_new());
+    rb_ivar_set(doc, ox_nodes_id, nodes);
     pi->h->obj = nodes;
     pi->obj = doc;
 }
@@ -119,7 +119,7 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	    VALUE	rstr = rb_str_new2(attrs->name);
 
 	    rb_enc_associate(rstr, pi->encoding);
-	    sym = rb_funcall(rstr, to_sym_id, 0);
+	    sym = rb_funcall(rstr, ox_to_sym_id, 0);
 	} else {
 	    sym = ID2SYM(rb_intern(attrs->name));
 	}
@@ -134,8 +134,8 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 #endif
     }
     nodes = rb_ary_new();
-    rb_ivar_set(doc, attributes_id, ah);
-    rb_ivar_set(doc, nodes_id, nodes);
+    rb_ivar_set(doc, ox_attributes_id, ah);
+    rb_ivar_set(doc, ox_nodes_id, nodes);
     pi->h->obj = nodes;
     pi->obj = doc;
 }
@@ -203,7 +203,7 @@ add_doctype(PInfo pi, const char *docType) {
         rb_enc_associate(s, pi->encoding);
     }
 #endif
-    rb_ivar_set(n, value_id, s);
+    rb_ivar_set(n, ox_value_id, s);
     if (0 == pi->h) { // top level object
 	create_doc(pi);
     }
@@ -220,7 +220,7 @@ add_comment(PInfo pi, const char *comment) {
         rb_enc_associate(s, pi->encoding);
     }
 #endif
-    rb_ivar_set(n, value_id, s);
+    rb_ivar_set(n, ox_value_id, s);
     if (0 == pi->h) { // top level object
 	create_doc(pi);
     }
@@ -237,7 +237,7 @@ add_cdata(PInfo pi, const char *cdata, size_t len) {
         rb_enc_associate(s, pi->encoding);
     }
 #endif
-    rb_ivar_set(n, value_id, s);
+    rb_ivar_set(n, ox_value_id, s);
     if (0 == pi->h) { // top level object
 	create_doc(pi);
     }
@@ -270,7 +270,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     }
 #endif
     e = rb_obj_alloc(ox_element_clas);
-    rb_ivar_set(e, value_id, s);
+    rb_ivar_set(e, ox_value_id, s);
     if (0 != attrs->name) {
         VALUE   ah = rb_hash_new();
         
@@ -278,13 +278,13 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
             VALUE   sym;
             VALUE   *slot;
 
-            if (Qundef == (sym = ox_cache_get(symbol_cache, attrs->name, &slot))) {
+            if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot))) {
 #ifdef HAVE_RUBY_ENCODING_H
 		if (0 != pi->encoding) {
 		    VALUE	rstr = rb_str_new2(attrs->name);
 
 		    rb_enc_associate(rstr, pi->encoding);
-		    sym = rb_funcall(rstr, to_sym_id, 0);
+		    sym = rb_funcall(rstr, ox_to_sym_id, 0);
 		} else {
 		    sym = ID2SYM(rb_intern(attrs->name));
 		}
@@ -301,7 +301,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 #endif
             rb_hash_aset(ah, sym, s);
         }
-        rb_ivar_set(e, attributes_id, ah);
+        rb_ivar_set(e, ox_attributes_id, ah);
     }
     if (0 == pi->h) { // top level object
         pi->h = pi->helpers;
@@ -313,7 +313,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (hasChildren) {
         VALUE   nodes = rb_ary_new();
 
-        rb_ivar_set(e, nodes_id, nodes);
+        rb_ivar_set(e, ox_nodes_id, nodes);
         pi->h->obj = nodes;
     }
 }