ox 2.14.3 → 2.14.7

data/ext/ox/gen_load.c

@@ -10,10 +10,9 @@
 #include <stdarg.h>
 
 #include "ruby.h"
-#if HAVE_RB_ENC_ASSOCIATE
 #include "ruby/encoding.h"
-#endif
 #include "ox.h"
+#include "intern.h"
 
 static void     instruct(PInfo pi, const char *target, Attr attrs, const char *content);
 static void	create_doc(PInfo pi);
@@ -103,7 +102,6 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 	    sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
 	    rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
 	} else if (Yes == pi->options->sym_keys) {
-#if HAVE_RB_ENC_ASSOCIATE
 	    if (0 != pi->options->rb_enc) {
 		VALUE	rstr = rb_str_new2(attrs->name);
 
@@ -113,20 +111,17 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
 		sym = ID2SYM(rb_intern(attrs->name));
 	    }
 	    sym = ID2SYM(rb_intern(attrs->name));
-#endif
 	    rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
 	} else {
-#if HAVE_RB_ENC_ASSOCIATE
 	    volatile VALUE	rstr = rb_str_new2(attrs->name);
 
 	    if (0 != pi->options->rb_enc) {
 		rb_enc_associate(rstr, pi->options->rb_enc);
 	    }
 	    rb_hash_aset(ah, rstr, rb_str_new2(attrs->value));
-	    if (0 == strcmp("encoding", attrs->name)) {
-		pi->options->rb_enc = rb_enc_find(attrs->value);
-	    }
-#endif
+	}
+	if (0 == strcmp("encoding", attrs->name)) {
+	    pi->options->rb_enc = rb_enc_find(attrs->value);
 	}
     }
     nodes = rb_ary_new();
@@ -195,11 +190,9 @@ add_doctype(PInfo pi, const char *docType) {
     VALUE       n = rb_obj_alloc(ox_doctype_clas);
     VALUE       s = rb_str_new2(docType);
 
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
 	create_doc(pi);
@@ -212,11 +205,9 @@ add_comment(PInfo pi, const char *comment) {
     VALUE       n = rb_obj_alloc(ox_comment_clas);
     VALUE       s = rb_str_new2(comment);
 
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
 	create_doc(pi);
@@ -229,11 +220,9 @@ add_cdata(PInfo pi, const char *cdata, size_t len) {
     VALUE       n = rb_obj_alloc(ox_cdata_clas);
     VALUE       s = rb_str_new2(cdata);
 
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     rb_ivar_set(n, ox_at_value_id, s);
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
 	create_doc(pi);
@@ -245,11 +234,9 @@ static void
 add_text(PInfo pi, char *text, int closed) {
     VALUE       s = rb_str_new2(text);
 
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
 	create_doc(pi);
     }
@@ -264,11 +251,9 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (Qnil != pi->options->element_key_mod) {
 	s = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, s);
     }
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     e = rb_obj_alloc(ox_element_clas);
     rb_ivar_set(e, ox_at_value_id, s);
     if (0 != attrs->name) {
@@ -280,40 +265,14 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 	    if (Qnil != pi->options->attr_key_mod) {
 		sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
 	    } else if (Yes == pi->options->sym_keys) {
-		VALUE	*slot;
-
-		if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot, 0))) {
-#if HAVE_RB_ENC_ASSOCIATE
-		    if (0 != pi->options->rb_enc) {
-			VALUE	rstr = rb_str_new2(attrs->name);
-
-			rb_enc_associate(rstr, pi->options->rb_enc);
-			sym = rb_funcall(rstr, ox_to_sym_id, 0);
-		    } else {
-			sym = ID2SYM(rb_intern(attrs->name));
-		    }
-#else
-		    sym = ID2SYM(rb_intern(attrs->name));
-#endif
-		    // Needed for Ruby 2.2 to get around the GC of symbols
-		    // created with to_sym which is needed for encoded symbols.
-		    rb_ary_push(ox_sym_bank, sym);
-		    *slot = sym;
-		}
+		sym = ox_sym_intern(attrs->name, strlen(attrs->name), NULL);
 	    } else {
-		sym = rb_str_new2(attrs->name);
-#if HAVE_RB_ENC_ASSOCIATE
-		if (0 != pi->options->rb_enc) {
-		    rb_enc_associate(sym, pi->options->rb_enc);
-		}
-#endif
+		sym = ox_str_intern(attrs->name, strlen(attrs->name), NULL);
 	    }
             s = rb_str_new2(attrs->value);
-#if HAVE_RB_ENC_ASSOCIATE
             if (0 != pi->options->rb_enc) {
                 rb_enc_associate(s, pi->options->rb_enc);
             }
-#endif
             rb_hash_aset(ah, sym, s);
         }
         rb_ivar_set(e, ox_attributes_id, ah);
@@ -349,14 +308,12 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
     if (0 != content) {
 	c = rb_str_new2(content);
     }
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
 	if (0 != content) {
 	    rb_enc_associate(c, pi->options->rb_enc);
 	}
     }
-#endif
     inst = rb_obj_alloc(ox_instruct_clas);
     rb_ivar_set(inst, ox_at_value_id, s);
     if (0 != content) {
@@ -366,43 +323,18 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
 
         for (; 0 != attrs->name; attrs++) {
             volatile VALUE	sym;
-	    VALUE		*slot;
 
 	    if (Qnil != pi->options->attr_key_mod) {
 		sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
 	    } else if (Yes == pi->options->sym_keys) {
-		if (Qundef == (sym = ox_cache_get(ox_symbol_cache, attrs->name, &slot, 0))) {
-#if HAVE_RB_ENC_ASSOCIATE
-		    if (0 != pi->options->rb_enc) {
-			VALUE	rstr = rb_str_new2(attrs->name);
-
-			rb_enc_associate(rstr, pi->options->rb_enc);
-			sym = rb_funcall(rstr, ox_to_sym_id, 0);
-		    } else {
-			sym = ID2SYM(rb_intern(attrs->name));
-		    }
-#else
-		    sym = ID2SYM(rb_intern(attrs->name));
-#endif
-		    // Needed for Ruby 2.2 to get around the GC of symbols
-		    // created with to_sym which is needed for encoded symbols.
-		    rb_ary_push(ox_sym_bank, sym);
-		    *slot = sym;
-		}
+		sym = ox_sym_intern(attrs->name, strlen(attrs->name), NULL);
 	    } else {
-		sym = rb_str_new2(attrs->name);
-#if HAVE_RB_ENC_ASSOCIATE
-		if (0 != pi->options->rb_enc) {
-		    rb_enc_associate(sym, pi->options->rb_enc);
-		}
-#endif
+		sym = ox_str_intern(attrs->name, strlen(attrs->name), NULL);
 	    }
             s = rb_str_new2(attrs->value);
-#if HAVE_RB_ENC_ASSOCIATE
             if (0 != pi->options->rb_enc) {
                 rb_enc_associate(s, pi->options->rb_enc);
             }
-#endif
             rb_hash_aset(ah, sym, s);
         }
         rb_ivar_set(inst, ox_attributes_id, ah);

data/ext/ox/hash_load.c

@@ -78,11 +78,9 @@ add_str(PInfo pi, VALUE s) {
     Helper		parent = helper_stack_peek(&pi->helpers);
     volatile VALUE	a;
 
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#endif
     switch (parent->type) {
     case NoCode:
 	parent->obj = s;
@@ -131,11 +129,9 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		key = rb_str_new2(attrs->name);
 	    }
 	    val = rb_str_new2(attrs->value);
-#if HAVE_RB_ENC_ASSOCIATE
 	    if (0 != pi->options->rb_enc) {
 		rb_enc_associate(val, pi->options->rb_enc);
 	    }
-#endif
 	    rb_hash_aset(h, key, val);
 	}
 	a = rb_ary_new();

data/ext/ox/intern.c

@@ -0,0 +1,158 @@
+// Copyright (c) 2011, 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "intern.h"
+
+#include <stdint.h>
+
+#include "cache.h"
+#include "ox.h"
+
+static struct _cache *str_cache = NULL;
+static VALUE          str_cache_obj;
+
+static struct _cache *sym_cache = NULL;
+static VALUE          sym_cache_obj;
+
+static struct _cache *attr_cache = NULL;
+static VALUE          attr_cache_obj;
+
+static struct _cache *id_cache = NULL;
+static VALUE          id_cache_obj;
+
+static VALUE form_str(const char *str, size_t len) {
+    return rb_str_freeze(rb_utf8_str_new(str, len));
+}
+
+static VALUE form_sym(const char *str, size_t len) {
+    return rb_to_symbol(rb_str_freeze(rb_utf8_str_new(str, len)));
+}
+
+static VALUE form_attr(const char *str, size_t len) {
+    char buf[256];
+
+    if (sizeof(buf) - 2 <= len) {
+        char *b = ALLOC_N(char, len + 2);
+        ID    id;
+
+        if ('~' == *str) {
+            memcpy(b, str + 1, len - 1);
+            b[len - 1] = '\0';
+            len -= 2;
+        } else {
+            *b = '@';
+            memcpy(b + 1, str, len);
+            b[len + 1] = '\0';
+        }
+        id = rb_intern3(buf, len + 1, rb_utf8_encoding());
+        xfree(b);
+        return id;
+    }
+    if ('~' == *str) {
+        memcpy(buf, str + 1, len - 1);
+        buf[len - 1] = '\0';
+        len -= 2;
+    } else {
+        *buf = '@';
+        memcpy(buf + 1, str, len);
+        buf[len + 1] = '\0';
+    }
+    return (VALUE)rb_intern3(buf, len + 1, rb_utf8_encoding());
+}
+
+static VALUE form_id(const char *str, size_t len) {
+    return (VALUE)rb_intern3(str, len, rb_utf8_encoding());
+}
+
+void ox_hash_init() {
+    VALUE cache_class = rb_define_class_under(Ox, "Cache", rb_cObject);
+
+    str_cache     = cache_create(0, form_str, true, false);
+    str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
+    rb_gc_register_address(&str_cache_obj);
+
+    sym_cache     = cache_create(0, form_sym, true, false);
+    sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
+    rb_gc_register_address(&sym_cache_obj);
+
+    attr_cache     = cache_create(0, form_attr, false, false);
+    attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
+    rb_gc_register_address(&attr_cache_obj);
+
+    id_cache     = cache_create(0, form_id, false, false);
+    id_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, id_cache);
+    rb_gc_register_address(&id_cache_obj);
+}
+
+VALUE
+ox_str_intern(const char *key, size_t len, const char **keyp) {
+    // For huge cache sizes over half a million the rb_enc_interned_str
+    // performs slightly better but at more "normal" size of a several
+    // thousands the cache intern performs about 20% better.
+#if HAVE_RB_ENC_INTERNED_STR && 0
+    return rb_enc_interned_str(key, len, rb_utf8_encoding());
+#else
+    return cache_intern(str_cache, key, len, keyp);
+#endif
+}
+
+VALUE
+ox_sym_intern(const char *key, size_t len, const char **keyp) {
+    return cache_intern(sym_cache, key, len, keyp);
+}
+
+ID ox_attr_intern(const char *key, size_t len) {
+    return cache_intern(attr_cache, key, len, NULL);
+}
+
+ID ox_id_intern(const char *key, size_t len) {
+    return cache_intern(id_cache, key, len, NULL);
+}
+
+char *ox_strndup(const char *s, size_t len) {
+    char *d = ALLOC_N(char, len + 1);
+
+    memcpy(d, s, len);
+    d[len] = '\0';
+
+    return d;
+}
+
+void intern_cleanup() {
+    cache_free(str_cache);
+    cache_free(sym_cache);
+    cache_free(attr_cache);
+    cache_free(id_cache);
+}
+
+VALUE
+ox_utf8_name(const char *str, size_t len, rb_encoding *encoding, const char **strp) {
+    return ox_str_intern(str, len, strp);
+}
+
+VALUE
+ox_utf8_sym(const char *str, size_t len, rb_encoding *encoding, const char **strp) {
+    return ox_sym_intern(str, len, strp);
+}
+
+VALUE
+ox_enc_sym(const char *str, size_t len, rb_encoding *encoding, const char **strp) {
+    VALUE sym = rb_str_new2(str);
+
+    rb_enc_associate(sym, encoding);
+    if (NULL != strp) {
+        *strp = StringValuePtr(sym);
+    }
+    return rb_to_symbol(sym);
+}
+
+VALUE
+ox_enc_name(const char *str, size_t len, rb_encoding *encoding, const char **strp) {
+    VALUE sym = rb_str_new2(str);
+
+    rb_enc_associate(sym, encoding);
+    if (NULL != strp) {
+        *strp = StringValuePtr(sym);
+    }
+    return sym;
+}

data/ext/ox/intern.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2011, 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+#ifndef OX_INTERN_H
+#define OX_INTERN_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+struct _parseInfo;
+
+extern void ox_hash_init();
+
+extern VALUE ox_str_intern(const char *key, size_t len, const char **keyp);
+extern VALUE ox_sym_intern(const char *key, size_t len, const char **keyp);
+extern ID    ox_attr_intern(const char *key, size_t len);
+extern ID    ox_id_intern(const char *key, size_t len);
+
+extern char *ox_strndup(const char *s, size_t len);
+
+extern VALUE ox_utf8_name(const char *str, size_t len, rb_encoding *encoding, const char **strp);
+extern VALUE ox_utf8_sym(const char *str, size_t len, rb_encoding *encoding, const char **strp);
+extern VALUE ox_enc_sym(const char *str, size_t len, rb_encoding *encoding, const char **strp);
+extern VALUE ox_enc_name(const char *str, size_t len, rb_encoding *encoding, const char **strp);
+
+#endif /* OX_INTERN_H */

data/ext/ox/obj_load.c

@@ -11,11 +11,10 @@
 #include <time.h>
 
 #include "ruby.h"
-#if HAVE_RB_ENC_ASSOCIATE
 #include "ruby/encoding.h"
-#endif
 #include "base64.h"
 #include "ox.h"
+#include "intern.h"
 
 static void	instruct(PInfo pi, const char *target, Attr attrs, const char *content);
 static void	add_text(PInfo pi, char *text, int closed);
@@ -56,56 +55,6 @@ ParseCallbacks	 ox_obj_callbacks = &_ox_obj_callbacks;
 
 extern ParseCallbacks	ox_gen_callbacks;
 
-
-inline static VALUE
-str2sym(const char *str, void *encoding) {
-    VALUE	sym;
-
-#ifdef HAVE_RUBY_ENCODING_H
-    if (0 != encoding) {
-	VALUE	rstr = rb_str_new2(str);
-
-	rb_enc_associate(rstr, (rb_encoding*)encoding);
-	sym = rb_funcall(rstr, ox_to_sym_id, 0);
-    } else {
-	sym = ID2SYM(rb_intern(str));
-    }
-#else
-    sym = ID2SYM(rb_intern(str));
-#endif
-    return sym;
-}
-
-inline static ID
-name2var(const char *name, void *encoding) {
-    VALUE	*slot;
-    ID		var_id = 0;
-
-    if ('0' <= *name && *name <= '9') {
-	var_id = INT2NUM(atoi(name));
-    } else if (Qundef == (var_id = ox_cache_get(ox_attr_cache, name, &slot, 0))) {
-#ifdef HAVE_RUBY_ENCODING_H
-	if (0 != encoding) {
-	    volatile VALUE	rstr = rb_str_new2(name);
-	    volatile VALUE	sym;
-
-	    rb_enc_associate(rstr, (rb_encoding*)encoding);
-	    sym = rb_funcall(rstr, ox_to_sym_id, 0);
-	    // Needed for Ruby 2.2 to get around the GC of symbols
-	    // created with to_sym which is needed for encoded symbols.
-	    rb_ary_push(ox_sym_bank, sym);
-	    var_id = SYM2ID(sym);
-	} else {
-	    var_id = rb_intern(name);
-	}
-#else
-	var_id = rb_intern(name);
-#endif
-	*slot = var_id;
-    }
-    return var_id;
-}
-
 inline static VALUE
 resolve_classname(VALUE mod, const char *class_name, Effort effort, VALUE base_class) {
     VALUE	clas;
@@ -228,6 +177,7 @@ classname2class(const char *name, PInfo pi, VALUE base_class) {
 	*s = '\0';
 	if (Qundef != (clas = resolve_classname(clas, class_name, pi->options->effort, base_class))) {
 	    *slot = clas;
+	    rb_gc_register_address(slot);
 	}
     }
     return clas;
@@ -237,8 +187,12 @@ static ID
 get_var_sym_from_attrs(Attr a, void *encoding) {
     for (; 0 != a->name; a++) {
 	if ('a' == *a->name && '\0' == *(a->name + 1)) {
-	    name2var(a->value, encoding);
-	    return name2var(a->value, encoding);
+	    const char	*val = a->value;
+
+	    if ('0' <= *val && *val <= '9') {
+		return INT2NUM(atoi(val));
+	    }
+	    return ox_id_intern(val, strlen(val));
 	}
     }
     return 0;
@@ -376,13 +330,11 @@ parse_regexp(const char *text) {
 static void
 instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
-#if HAVE_RB_ENC_FIND
 	for (; 0 != attrs->name; attrs++) {
 	    if (0 == strcmp("encoding", attrs->name)) {
 		pi->options->rb_enc = rb_enc_find(attrs->value);
 	    }
 	}
-#endif
     }
 }
 
@@ -408,11 +360,9 @@ add_text(PInfo pi, char *text, int closed) {
     case NoCode:
     case StringCode:
 	h->obj = rb_str_new2(text);
-#if HAVE_RB_ENC_ASSOCIATE
 	if (0 != pi->options->rb_enc) {
 	    rb_enc_associate(h->obj, pi->options->rb_enc);
 	}
-#endif
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, h->obj, (unsigned long)pi->id);
 	}
@@ -446,20 +396,8 @@ add_text(PInfo pi, char *text, int closed) {
 	h->obj = rb_float_new(strtod(text, 0));
 	break;
     case SymbolCode:
-    {
-	VALUE	sym;
-	VALUE	*slot;
-
-	if (Qundef == (sym = ox_cache_get(ox_symbol_cache, text, &slot, 0))) {
-	    sym = str2sym(text, (void*)pi->options->rb_enc);
-	    // Needed for Ruby 2.2 to get around the GC of symbols created with
-	    // to_sym which is needed for encoded symbols.
-	    rb_ary_push(ox_sym_bank, sym);
-	    *slot = sym;
-	}
-	h->obj = sym;
+	h->obj = ox_sym_intern(text, strlen(text), NULL);
 	break;
-    }
     case DateCode:
     {
 	VALUE	args[1];
@@ -481,11 +419,9 @@ add_text(PInfo pi, char *text, int closed) {
 
 	from_base64(text, (uchar*)str);
 	v = rb_str_new(str, str_size);
-#if HAVE_RB_ENC_ASSOCIATE
 	if (0 != pi->options->rb_enc) {
 	    rb_enc_associate(v, pi->options->rb_enc);
 	}
-#endif
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, v, (unsigned long)h->obj);
 	}
@@ -494,20 +430,11 @@ add_text(PInfo pi, char *text, int closed) {
     }
     case Symbol64Code:
     {
-	VALUE		sym;
-	VALUE		*slot;
 	unsigned long	str_size = b64_orig_size(text);
 	char		*str = ALLOCA_N(char, str_size + 1);
 
 	from_base64(text, (uchar*)str);
-	if (Qundef == (sym = ox_cache_get(ox_symbol_cache, str, &slot, 0))) {
-	    sym = str2sym(str, (void*)pi->options->rb_enc);
-	    // Needed for Ruby 2.2 to get around the GC of symbols created with
-	    // to_sym which is needed for encoded symbols.
-	    rb_ary_push(ox_sym_bank, sym);
-	    *slot = sym;
-	}
-	h->obj = sym;
+	h->obj = ox_sym_intern(str, strlen(str), NULL);
 	break;
     }
     case RegexpCode:
@@ -843,7 +770,7 @@ parse_double_time(const char *text, VALUE clas) {
     for (; text - dot <= 9; text++) {
 	v2 *= 10;
     }
-#if HAS_NANO_TIME
+#if HAVE_RB_TIME_NANO_NEW
     return rb_time_nano_new(v, v2);
 #else
     return rb_time_new(v, v2 / 1000);
@@ -899,7 +826,7 @@ parse_xsd_time(const char *text, VALUE clas) {
     tm.tm_hour = (int)cargs[3];
     tm.tm_min = (int)cargs[4];
     tm.tm_sec = (int)cargs[5];
-#if HAS_NANO_TIME
+#if HAVE_RB_TIME_NANO_NEW
     return rb_time_nano_new(mktime(&tm), cargs[6]);
 #else
     return rb_time_new(mktime(&tm), cargs[6] / 1000);