ox-bundlecachetest 2.14.23

data/ext/ox/hash_load.c

@@ -0,0 +1,309 @@
+/* hash_load.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ox.h"
+#include "ruby.h"
+
+#define MARK_INC 256
+
+// The approach taken for the hash and has_no_attrs parsing is to push just
+// the key on to the stack and then decide what to do on the way up/out.
+
+static VALUE create_top(PInfo pi) {
+    volatile VALUE top = rb_hash_new();
+
+    helper_stack_push(&pi->helpers, 0, top, HashCode);
+    pi->obj = top;
+
+    return top;
+}
+
+static void mark_value(PInfo pi, VALUE val) {
+    if (NULL == pi->marked) {
+        pi->marked    = ALLOC_N(VALUE, MARK_INC);
+        pi->mark_size = MARK_INC;
+    } else if (pi->mark_size <= pi->mark_cnt) {
+        pi->mark_size += MARK_INC;
+        REALLOC_N(pi->marked, VALUE, pi->mark_size);
+    }
+    pi->marked[pi->mark_cnt] = val;
+    pi->mark_cnt++;
+}
+
+static bool marked(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+        VALUE *vp = pi->marked + pi->mark_cnt - 1;
+
+        for (; pi->marked <= vp; vp--) {
+            if (val == *vp) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static void unmark(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+        VALUE *vp = pi->marked + pi->mark_cnt - 1;
+        int    i;
+
+        for (i = 0; pi->marked <= vp; vp--, i++) {
+            if (val == *vp) {
+                for (; 0 < i; i--, vp++) {
+                    *vp = *(vp + 1);
+                }
+                pi->mark_cnt--;
+                break;
+            }
+        }
+    }
+}
+
+static void add_str(PInfo pi, VALUE s) {
+    Helper         parent = helper_stack_peek(&pi->helpers);
+    volatile VALUE a;
+
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    switch (parent->type) {
+    case NoCode:
+        parent->obj  = s;
+        parent->type = StringCode;
+        break;
+    case ArrayCode: rb_ary_push(parent->obj, s); break;
+    default:
+        a = rb_ary_new();
+        rb_ary_push(a, parent->obj);
+        rb_ary_push(a, s);
+        parent->obj  = a;
+        parent->type = ArrayCode;
+        break;
+    }
+}
+
+static void add_text(PInfo pi, char *text, int closed) {
+    VALUE s = rb_str_new2(text);
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    add_str(pi, s);
+}
+
+static void add_cdata(PInfo pi, const char *text, size_t len) {
+    VALUE s = rb_str_new2(text);
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    add_str(pi, s);
+}
+
+static void add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+    VALUE s = rb_str_new2(ename);
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    if (helper_stack_empty(&pi->helpers)) {
+        create_top(pi);
+    }
+    if (NULL != attrs && NULL != attrs->name) {
+        volatile VALUE h = rb_hash_new();
+        volatile VALUE key;
+        volatile VALUE val;
+        volatile VALUE a;
+
+        for (; 0 != attrs->name; attrs++) {
+            key = rb_str_new2(attrs->name);
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(key, pi->options->rb_enc);
+            }
+            if (Qnil != pi->options->attr_key_mod) {
+                key = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, key);
+            } else if (Yes == pi->options->sym_keys) {
+                key = rb_id2sym(rb_intern_str(key));
+            }
+            val = rb_str_new2(attrs->value);
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(val, pi->options->rb_enc);
+            }
+            rb_hash_aset(h, key, val);
+        }
+        a = rb_ary_new();
+        rb_ary_push(a, h);
+        mark_value(pi, a);
+        helper_stack_push(&pi->helpers, rb_intern_str(s), a, ArrayCode);
+    } else {
+        helper_stack_push(&pi->helpers, rb_intern_str(s), Qnil, NoCode);
+    }
+}
+
+static void add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+    VALUE s = rb_str_new2(ename);
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    if (helper_stack_empty(&pi->helpers)) {
+        create_top(pi);
+    }
+    helper_stack_push(&pi->helpers, rb_intern_str(s), Qnil, NoCode);
+}
+
+static int umark_hash_cb(VALUE key, VALUE value, VALUE x) {
+    unmark((PInfo)x, value);
+
+    return ST_CONTINUE;
+}
+
+static void end_element_core(PInfo pi, const char *ename, bool check_marked) {
+    Helper         e      = helper_stack_pop(&pi->helpers);
+    Helper         parent = helper_stack_peek(&pi->helpers);
+    volatile VALUE pobj   = parent->obj;
+    volatile VALUE found  = Qundef;
+    volatile VALUE key;
+    volatile VALUE a;
+
+    if (NoCode == e->type) {
+        e->obj = Qnil;
+    }
+    if (Qnil != pi->options->element_key_mod) {
+        key = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, rb_id2str(e->var));
+    } else if (Yes == pi->options->sym_keys) {
+        key = rb_id2sym(e->var);
+    } else {
+        key = rb_id2str(e->var);
+    }
+    // Make sure the parent is a Hash. If not set then make a Hash. If an
+    // Array or non-Hash then append to array or create and append.
+    switch (parent->type) {
+    case NoCode:
+        pobj         = rb_hash_new();
+        parent->obj  = pobj;
+        parent->type = HashCode;
+        break;
+    case ArrayCode:
+        pobj = rb_hash_new();
+        rb_ary_push(parent->obj, pobj);
+        break;
+    case HashCode: found = rb_hash_lookup2(parent->obj, key, Qundef); break;
+    default:
+        a = rb_ary_new();
+        rb_ary_push(a, parent->obj);
+        pobj = rb_hash_new();
+        rb_ary_push(a, pobj);
+        parent->obj  = a;
+        parent->type = ArrayCode;
+        break;
+    }
+    if (Qundef == found) {
+        rb_hash_aset(pobj, key, e->obj);
+    } else if (RUBY_T_ARRAY == rb_type(found)) {
+        if (check_marked && marked(pi, found)) {
+            unmark(pi, found);
+            a = rb_ary_new();
+            rb_ary_push(a, found);
+            rb_ary_push(a, e->obj);
+            rb_hash_aset(pobj, key, a);
+        } else {
+            rb_ary_push(found, e->obj);
+        }
+    } else {  // something there other than an array
+        if (check_marked && marked(pi, e->obj)) {
+            unmark(pi, e->obj);
+        }
+        a = rb_ary_new();
+        rb_ary_push(a, found);
+        rb_ary_push(a, e->obj);
+        rb_hash_aset(pobj, key, a);
+    }
+    if (check_marked && NULL != pi->marked && RUBY_T_HASH == rb_type(e->obj)) {
+        rb_hash_foreach(e->obj, umark_hash_cb, (VALUE)pi);
+    }
+}
+
+static void end_element(PInfo pi, const char *ename) {
+    end_element_core(pi, ename, true);
+}
+
+static void end_element_no_attrs(PInfo pi, const char *ename) {
+    end_element_core(pi, ename, false);
+}
+
+static void finish(PInfo pi) {
+    xfree(pi->marked);
+}
+
+static void set_encoding_from_instruct(PInfo pi, Attr attrs) {
+    for (; 0 != attrs->name; attrs++) {
+        if (0 == strcmp("encoding", attrs->name)) {
+            pi->options->rb_enc = rb_enc_find(attrs->value);
+        }
+    }
+}
+
+static void instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
+    if (0 == strcmp("xml", target)) {
+        set_encoding_from_instruct(pi, attrs);
+    }
+}
+
+struct _parseCallbacks _ox_hash_callbacks = {
+    instruct,
+    NULL,
+    NULL,
+    NULL,
+    add_text,
+    add_element,
+    end_element,
+    finish,
+};
+
+ParseCallbacks ox_hash_callbacks = &_ox_hash_callbacks;
+
+struct _parseCallbacks _ox_hash_cdata_callbacks = {
+    instruct,
+    NULL,
+    NULL,
+    add_cdata,
+    add_text,
+    add_element,
+    end_element,
+    finish,
+};
+
+ParseCallbacks ox_hash_cdata_callbacks = &_ox_hash_cdata_callbacks;
+
+struct _parseCallbacks _ox_hash_no_attrs_callbacks = {
+    instruct,
+    NULL,
+    NULL,
+    NULL,
+    add_text,
+    add_element_no_attrs,
+    end_element_no_attrs,
+    NULL,
+};
+
+ParseCallbacks ox_hash_no_attrs_callbacks = &_ox_hash_no_attrs_callbacks;
+
+struct _parseCallbacks _ox_hash_no_attrs_cdata_callbacks = {
+    instruct,
+    NULL,
+    NULL,
+    add_cdata,
+    add_text,
+    add_element_no_attrs,
+    end_element_no_attrs,
+    NULL,
+};
+
+ParseCallbacks ox_hash_no_attrs_cdata_callbacks = &_ox_hash_no_attrs_cdata_callbacks;

data/ext/ox/helper.h

@@ -0,0 +1,84 @@
+/* helper.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OX_HELPER_H
+#define OX_HELPER_H
+
+#include "type.h"
+
+#define HELPER_STACK_INC 16
+
+typedef struct _helper {
+    ID    var;  /* Object var ID */
+    VALUE obj;  /* object created or Qundef if not appropriate */
+    Type  type; /* type of object in obj */
+} *Helper;
+
+typedef struct _helperStack {
+    struct _helper base[HELPER_STACK_INC];
+    Helper         head; /* current stack */
+    Helper         end;  /* stack end */
+    Helper         tail; /* pointer to one past last element name on stack */
+} *HelperStack;
+
+inline static void helper_stack_init(HelperStack stack) {
+    stack->head = stack->base;
+    stack->end  = stack->base + sizeof(stack->base) / sizeof(struct _helper);
+    stack->tail = stack->head;
+}
+
+inline static int helper_stack_empty(HelperStack stack) {
+    return (stack->head == stack->tail);
+}
+
+inline static int helper_stack_depth(HelperStack stack) {
+    return (int)(stack->tail - stack->head);
+}
+
+inline static void helper_stack_cleanup(HelperStack stack) {
+    if (stack->base != stack->head) {
+        xfree(stack->head);
+        stack->head = stack->base;
+    }
+}
+
+inline static Helper helper_stack_push(HelperStack stack, ID var, VALUE obj, Type type) {
+    if (stack->end <= stack->tail) {
+        size_t len  = stack->end - stack->head;
+        size_t toff = stack->tail - stack->head;
+
+        if (stack->base == stack->head) {
+            stack->head = ALLOC_N(struct _helper, len + HELPER_STACK_INC);
+            memcpy(stack->head, stack->base, sizeof(struct _helper) * len);
+        } else {
+            REALLOC_N(stack->head, struct _helper, len + HELPER_STACK_INC);
+        }
+        stack->tail = stack->head + toff;
+        stack->end  = stack->head + len + HELPER_STACK_INC;
+    }
+    stack->tail->var  = var;
+    stack->tail->obj  = obj;
+    stack->tail->type = type;
+    stack->tail++;
+
+    return stack->tail - 1;
+}
+
+inline static Helper helper_stack_peek(HelperStack stack) {
+    if (stack->head < stack->tail) {
+        return stack->tail - 1;
+    }
+    return 0;
+}
+
+inline static Helper helper_stack_pop(HelperStack stack) {
+    if (stack->head < stack->tail) {
+        stack->tail--;
+        return stack->tail;
+    }
+    return 0;
+}
+
+#endif /* OX_HELPER_H */

data/ext/ox/intern.c

@@ -0,0 +1,157 @@
+// 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"
+#include "ruby/version.h"
+
+// These are statics but in an attempt to stop the cross linking or maybe
+// something in Ruby they all have been given an ox prefix.
+static struct _cache *ox_str_cache = NULL;
+static VALUE          ox_str_cache_obj;
+
+static struct _cache *ox_sym_cache = NULL;
+static VALUE          ox_sym_cache_obj;
+
+static struct _cache *ox_attr_cache = NULL;
+static VALUE          ox_attr_cache_obj;
+
+static struct _cache *ox_id_cache = NULL;
+static VALUE          ox_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(void) {
+    VALUE cache_class = rb_define_class_under(Ox, "Cache", rb_cObject);
+#if RUBY_API_VERSION_CODE >= 30200
+    rb_undef_alloc_func(cache_class);
+#endif
+
+    ox_str_cache     = ox_cache_create(0, form_str, true, false);
+    ox_str_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_str_cache);
+    rb_gc_register_address(&ox_str_cache_obj);
+
+    ox_sym_cache     = ox_cache_create(0, form_sym, true, false);
+    ox_sym_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_sym_cache);
+    rb_gc_register_address(&ox_sym_cache_obj);
+
+    ox_attr_cache     = ox_cache_create(0, form_attr, false, false);
+    ox_attr_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_attr_cache);
+    rb_gc_register_address(&ox_attr_cache_obj);
+
+    ox_id_cache     = ox_cache_create(0, form_id, false, false);
+    ox_id_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_id_cache);
+    rb_gc_register_address(&ox_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 ox_cache_intern(ox_str_cache, key, len, keyp);
+#endif
+}
+
+VALUE
+ox_sym_intern(const char *key, size_t len, const char **keyp) {
+    return ox_cache_intern(ox_sym_cache, key, len, keyp);
+}
+
+ID ox_attr_intern(const char *key, size_t len) {
+    return ox_cache_intern(ox_attr_cache, key, len, NULL);
+}
+
+ID ox_id_intern(const char *key, size_t len) {
+    return ox_cache_intern(ox_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;
+}
+
+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 */