ox 2.14.7 → 2.14.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d34e2f569a6f870bc46c1ed8bf2e39e860f63ee8da1ad8aec0897e11904d8444
-  data.tar.gz: 90049302c1ba8e443a28aa1e69115db636ae86517695c6aab278fc8f7dcc8590
+  metadata.gz: e6a58bfa91298fd0da2d02538dfe039bb5a426edfba8e4f245d8bd91b7388cbb
+  data.tar.gz: 77765350035814045329fa94935cd3de29975eaefbaef1666e4ffe29269338d8
 SHA512:
-  metadata.gz: 2f5f3e9ef3f7172a7c25b43b00a92c57858e052e592ec7265077dabf1ab8280888953639232ca06e088e4524287e4f264ac3ddfe017dfde9d5c5b8dc5bd847a8
-  data.tar.gz: 35ebe783817b228b82eaacfcbdc7805de7327ad77fcf34f605baf7fab53103b79f5bd893c13b9a1a8f74f2e529b241ae805a21f487993db229e03b817f78aabf
+  metadata.gz: 9ac7c0bd9c0ac54cd033f432a0e14cd29b265b078459025c889ca08a907703d1aa202aee9ccae792e87a47b783bacf3044e62bedfc0c25090457dd5035ee2ee3
+  data.tar.gz: 73fc0775f561ca3290b6f6a875d0c8076d4434a642f0c0e7321952ed8b1adc655aa0f880916e1fde5f02f0d29b5c7cc57de871e4e58c869540c219bd46d75403

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All changes to the Ox gem are documented here. Releases follow semantic versioning.
 
+## [2.14.10] - 2022-03-10
+
+### Fixed
+
+- Writing strings over 16K to a file with builder no longer causes a crash.
+
+## [2.14.9] - 2022-02-11
+
+### Fixed
+
+- Fixed the `\r` replacement with `\n` with the SAX parser according to https://www.w3.org/TR/2008/REC-xml-20081126/#sec-line-ends.
+
+## [2.14.8] - 2022-02-09
+
+### Fixed
+
+- Renamed internal functions to avoid linking issues where Oj and Ox function names collided.
+
 ## [2.14.7] - 2022-02-03
 
 ### Fixed

data/ext/ox/buf.h

@@ -86,8 +86,16 @@ buf_append_string(Buf buf, const char *s, size_t slen) {
 
 	    if (len != (size_t)write(buf->fd, buf->head, len)) {
 		buf->err = true;
+		return;
 	    }
 	    buf->tail = buf->head;
+	    if (sizeof(buf->base) <= slen) {
+		if (slen != (size_t)write(buf->fd, s, slen)) {
+		    buf->err = true;
+		    return;
+		}
+		return;
+	    }
 	} else {
 	    size_t	len = buf->end - buf->head;
 	    size_t	toff = buf->tail - buf->head;

data/ext/ox/cache.c

@@ -28,7 +28,7 @@
 #define M 0x5bd1e995
 
 typedef struct _slot {
-    struct _slot *    next;
+    struct _slot     *next;
     VALUE             val;
     uint64_t          hash;
     volatile uint32_t use_cnt;
@@ -37,7 +37,7 @@ typedef struct _slot {
 } * Slot;
 
 typedef struct _cache {
-    volatile Slot * slots;
+    volatile Slot  *slots;
     volatile size_t cnt;
     VALUE (*form)(const char *str, size_t len);
     uint64_t size;
@@ -54,10 +54,6 @@ typedef struct _cache {
     bool    mark;
 } * Cache;
 
-void cache_set_form(Cache c, VALUE (*form)(const char *str, size_t len)) {
-    c->form = form;
-}
-
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
     const uint8_t *end     = key + len;
     const uint8_t *endless = key + (len & 0xFFFFFFFC);
@@ -94,8 +90,8 @@ static uint64_t hash_calc(const uint8_t *key, size_t len) {
 
 static void rehash(Cache c) {
     uint64_t osize;
-    Slot *   end;
-    Slot *   sp;
+    Slot    *end;
+    Slot    *sp;
 
     osize    = c->size;
     c->size  = osize * 4;
@@ -110,7 +106,7 @@ static void rehash(Cache c) {
         *sp = NULL;
         for (; NULL != s; s = next) {
             uint64_t h      = s->hash & c->mask;
-            Slot *   bucket = (Slot *)c->slots + h;
+            Slot    *bucket = (Slot *)c->slots + h;
 
             next    = s->next;
             s->next = *bucket;
@@ -119,9 +115,9 @@ static void rehash(Cache c) {
     }
 }
 
-static VALUE lockless_intern(Cache c, const char *key, size_t len, const char **keyp) {
+static VALUE ox_lockless_intern(Cache c, const char *key, size_t len, const char **keyp) {
     uint64_t       h      = hash_calc((const uint8_t *)key, len);
-    Slot *         bucket = (Slot *)c->slots + (h & c->mask);
+    Slot          *bucket = (Slot *)c->slots + (h & c->mask);
     Slot           b;
     volatile VALUE rkey;
 
@@ -169,9 +165,9 @@ static VALUE lockless_intern(Cache c, const char *key, size_t len, const char **
     return rkey;
 }
 
-static VALUE locking_intern(Cache c, const char *key, size_t len, const char **keyp) {
+static VALUE ox_locking_intern(Cache c, const char *key, size_t len, const char **keyp) {
     uint64_t       h;
-    Slot *         bucket;
+    Slot          *bucket;
     Slot           b;
     uint64_t       old_size;
     volatile VALUE rkey;
@@ -239,10 +235,7 @@ static VALUE locking_intern(Cache c, const char *key, size_t len, const char **k
     return rkey;
 }
 
-Cache cache_create(size_t size,
-                   VALUE (*form)(const char *str, size_t len),
-                   bool mark,
-                   bool locking) {
+Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking) {
     Cache c     = calloc(1, sizeof(struct _cache));
     int   shift = 0;
 
@@ -263,18 +256,14 @@ Cache cache_create(size_t size,
     c->xrate = 1;  // low
     c->mark  = mark;
     if (locking) {
-        c->intern = locking_intern;
+        c->intern = ox_locking_intern;
     } else {
-        c->intern = lockless_intern;
+        c->intern = ox_lockless_intern;
     }
     return c;
 }
 
-void cache_set_expunge_rate(Cache c, int rate) {
-    c->xrate = (uint8_t)rate;
-}
-
-void cache_free(Cache c) {
+void ox_cache_free(Cache c) {
     uint64_t i;
 
     for (i = 0; i < c->size; i++) {
@@ -290,7 +279,7 @@ void cache_free(Cache c) {
     free(c);
 }
 
-void cache_mark(Cache c) {
+void ox_cache_mark(Cache c) {
     uint64_t i;
 
 #if !HAVE_PTHREAD_MUTEX_INIT
@@ -333,7 +322,7 @@ void cache_mark(Cache c) {
 }
 
 VALUE
-cache_intern(Cache c, const char *key, size_t len, const char **keyp) {
+ox_cache_intern(Cache c, const char *key, size_t len, const char **keyp) {
     if (CACHE_MAX_KEY <= len) {
         if (NULL != keyp) {
             volatile VALUE rkey = c->form(key, len);

data/ext/ox/cache.h

@@ -1,8 +1,8 @@
 // Copyright (c) 2021 Peter Ohler. All rights reserved.
 // Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#ifndef CACHE_H
-#define CACHE_H
+#ifndef OX_CACHE_H
+#define OX_CACHE_H
 
 #include <ruby.h>
 #include <stdbool.h>
@@ -11,11 +11,9 @@
 
 struct _cache;
 
-extern struct _cache *cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
-extern void           cache_free(struct _cache *c);
-extern void           cache_mark(struct _cache *c);
-extern void           cache_set_form(struct _cache *c, VALUE (*form)(const char *str, size_t len));
-extern VALUE          cache_intern(struct _cache *c, const char *key, size_t len, const char **keyp);
-extern void           cache_set_expunge_rate(struct _cache *c, int rate);
+extern struct _cache *ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
+extern void           ox_cache_free(struct _cache *c);
+extern void           ox_cache_mark(struct _cache *c);
+extern VALUE          ox_cache_intern(struct _cache *c, const char *key, size_t len, const char **keyp);
 
-#endif /* CACHE_H */
+#endif /* OX_CACHE_H */

data/ext/ox/intern.c

@@ -8,17 +8,19 @@
 #include "cache.h"
 #include "ox.h"
 
-static struct _cache *str_cache = NULL;
-static VALUE          str_cache_obj;
+// 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 *sym_cache = NULL;
-static VALUE          sym_cache_obj;
+static struct _cache *ox_sym_cache = NULL;
+static VALUE          ox_sym_cache_obj;
 
-static struct _cache *attr_cache = NULL;
-static VALUE          attr_cache_obj;
+static struct _cache *ox_attr_cache = NULL;
+static VALUE          ox_attr_cache_obj;
 
-static struct _cache *id_cache = NULL;
-static VALUE          id_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));
@@ -67,21 +69,21 @@ static VALUE form_id(const char *str, size_t len) {
 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);
+    ox_str_cache     = ox_cache_create(0, form_str, true, false);
+    ox_str_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_str_cache);
+    rb_gc_register_address(&ox_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);
+    ox_sym_cache     = ox_cache_create(0, form_sym, true, false);
+    ox_sym_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_sym_cache);
+    rb_gc_register_address(&ox_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);
+    ox_attr_cache     = ox_cache_create(0, form_attr, false, false);
+    ox_attr_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_attr_cache);
+    rb_gc_register_address(&ox_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);
+    ox_id_cache     = ox_cache_create(0, form_id, false, false);
+    ox_id_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_id_cache);
+    rb_gc_register_address(&ox_id_cache_obj);
 }
 
 VALUE
@@ -92,21 +94,21 @@ ox_str_intern(const char *key, size_t len, const char **keyp) {
 #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);
+    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 cache_intern(sym_cache, key, len, keyp);
+    return ox_cache_intern(ox_sym_cache, key, len, keyp);
 }
 
 ID ox_attr_intern(const char *key, size_t len) {
-    return cache_intern(attr_cache, key, len, NULL);
+    return ox_cache_intern(ox_attr_cache, key, len, NULL);
 }
 
 ID ox_id_intern(const char *key, size_t len) {
-    return cache_intern(id_cache, key, len, NULL);
+    return ox_cache_intern(ox_id_cache, key, len, NULL);
 }
 
 char *ox_strndup(const char *s, size_t len) {
@@ -118,13 +120,6 @@ char *ox_strndup(const char *s, size_t len) {
     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);

data/ext/ox/obj_load.c

@@ -12,6 +12,7 @@
 
 #include "ruby.h"
 #include "ruby/encoding.h"
+
 #include "base64.h"
 #include "ox.h"
 #include "intern.h"
@@ -152,7 +153,7 @@ classname2class(const char *name, PInfo pi, VALUE base_class) {
     VALUE	*slot;
     VALUE	clas;
 
-    if (Qundef == (clas = ox_cache_get(ox_class_cache, name, &slot, 0))) {
+    if (Qundef == (clas = slot_cache_get(ox_class_cache, name, &slot, 0))) {
 	char		class_name[1024];
 	char		*s;
 	const char	*n = name;

data/ext/ox/ox.c

@@ -107,9 +107,7 @@ VALUE ox_struct_class;
 VALUE ox_syntax_error_class;
 VALUE ox_time_class;
 
-Cache ox_symbol_cache = 0;
-Cache ox_class_cache  = 0;
-Cache ox_attr_cache   = 0;
+SlotCache ox_class_cache  = 0;
 
 static VALUE abort_sym;
 static VALUE active_sym;
@@ -1646,9 +1644,7 @@ void Init_ox() {
     rb_gc_register_address(&ox_time_class);
     rb_gc_register_address(&ox_version_sym);
 
-    ox_cache_new(&ox_symbol_cache);
-    ox_cache_new(&ox_class_cache);
-    ox_cache_new(&ox_attr_cache);
+    slot_cache_new(&ox_class_cache);
 
     ox_sax_define();
     ox_hash_init();

data/ext/ox/ox.h

@@ -28,7 +28,7 @@ extern "C" {
 #include "attr.h"
 #include "err.h"
 #include "helper.h"
-#include "oxcache.h"
+#include "slotcache.h"
 #include "type.h"
 
 #define raise_error(msg, xml, current) _ox_raise_error(msg, xml, current, __FILE__, __LINE__)
@@ -238,9 +238,7 @@ extern VALUE ox_raw_clas;
 extern VALUE ox_doctype_clas;
 extern VALUE ox_cdata_clas;
 
-extern Cache ox_symbol_cache;
-extern Cache ox_class_cache;
-extern Cache ox_attr_cache;
+extern SlotCache ox_class_cache;
 
 extern void ox_init_builder(VALUE ox);
 

data/ext/ox/parse.c

@@ -108,7 +108,7 @@ static void fix_newlines(char *buf) {
 		if ('\n' == *(s + 1)) {
 		    continue;
 		}
-		*s = '\n';
+		*d = '\n';
 	    } else if (d < s) {
 		*d = *s;
 	    }

data/ext/ox/sax.c

@@ -307,8 +307,8 @@ static void sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, SaxOptions opti
         dr->encoding = rb_enc_find(ox_default_options.encoding);
     }
     dr->utf8 = (NULL == dr->encoding || rb_utf8_encoding() == dr->encoding);
-    if (NULL == dr->encoding || rb_utf8_encoding() == dr->encoding) {  // UTF-8
-        dr->get_name = dr->options.symbolize ? ox_utf8_sym : ox_utf8_name; // TBD UTF8 sym?
+    if (NULL == dr->encoding || rb_utf8_encoding() == dr->encoding) {       // UTF-8
+        dr->get_name = dr->options.symbolize ? ox_utf8_sym : ox_utf8_name;  // TBD UTF8 sym?
     } else {
         dr->get_name = dr->options.symbolize ? ox_enc_sym : ox_enc_name;
     }
@@ -334,7 +334,7 @@ static char skipBOM(SaxDrive dr) {
     if (0xEF == (uint8_t)c) { /* only UTF8 is supported */
         if (0xBB == (uint8_t)buf_get(&dr->buf) && 0xBF == (uint8_t)buf_get(&dr->buf)) {
             dr->encoding = ox_utf8_encoding;
-            c = buf_get(&dr->buf);
+            c            = buf_get(&dr->buf);
         } else {
             ox_sax_drive_error(dr, BAD_BOM "invalid BOM or a binary file.");
             c = '\0';
@@ -1217,7 +1217,7 @@ static char read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml,
             attr_value = dr->buf.str;
             if (is_encoding) {
                 dr->encoding = rb_enc_find(dr->buf.str);
-                is_encoding = 0;
+                is_encoding  = 0;
             }
         }
         if (0 >= dr->blocked && (NULL == h || ActiveOverlay == h->overlay || NestOverlay == h->overlay)) {
@@ -1368,7 +1368,8 @@ int ox_sax_collapse_special(SaxDrive dr, char *str, long pos, long line, long co
     char *b = str;
 
     while ('\0' != *s) {
-        if ('&' == *s) {
+        switch (*s) {
+        case '&': {
             int   c = 0;
             char *end;
 
@@ -1458,13 +1459,25 @@ int ox_sax_collapse_special(SaxDrive dr, char *str, long pos, long line, long co
             }
             *b++ = (char)c;
             col++;
-        } else {
+            break;
+        }
+        case '\r':
+	    s++;
             if ('\n' == *s) {
-                line++;
-                col = 0;
-            }
+		continue;
+	    }
+	    line++;
+	    col = 1;
+            *b++ = '\n';
+	    break;
+	case '\n':
+	    line++;
+	    col = 0;
+	    // fall through
+        default:
             col++;
             *b++ = *s++;
+            break;
         }
     }
     *b = '\0';

data/ext/ox/slotcache.c

@@ -0,0 +1,158 @@
+/* slotcache.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "slotcache.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+struct _slotCache {
+    /* The key is a length byte followed by the key as a string. If the key is longer than 254 characters then the
+       length is 255. The key can be for a premature value and in that case the length byte is greater than the length
+       of the key. */
+    char              *key;
+    VALUE              value;
+    struct _slotCache *slots[16];
+};
+
+static void slot_print(SlotCache cache, unsigned int depth);
+
+static char *form_key(const char *s) {
+    size_t len = strlen(s);
+    char  *d   = ALLOC_N(char, len + 2);
+
+    *(uint8_t *)d = (255 <= len) ? 255 : len;
+    memcpy(d + 1, s, len + 1);
+
+    return d;
+}
+
+void slot_cache_new(SlotCache *cache) {
+    *cache          = ALLOC(struct _slotCache);
+    (*cache)->key   = 0;
+    (*cache)->value = Qundef;
+    memset((*cache)->slots, 0, sizeof((*cache)->slots));
+}
+
+VALUE
+slot_cache_get(SlotCache cache, const char *key, VALUE **slot, const char **keyp) {
+    unsigned char *k = (unsigned char *)key;
+    SlotCache     *cp;
+
+    for (; '\0' != *k; k++) {
+        cp = cache->slots + (unsigned int)(*k >> 4); /* upper 4 bits */
+        if (0 == *cp) {
+            slot_cache_new(cp);
+        }
+        cache = *cp;
+        cp    = cache->slots + (unsigned int)(*k & 0x0F); /* lower 4 bits */
+        if (0 == *cp) { /* nothing on this tree so set key and value as a premature key/value pair */
+            slot_cache_new(cp);
+            cache      = *cp;
+            cache->key = form_key(key);
+            break;
+        } else {
+            int depth = (int)(k - (unsigned char *)key + 1);
+
+            cache = *cp;
+
+            if ('\0' == *(k + 1)) {    /* exact match */
+                if (0 == cache->key) { /* nothing in this spot so take it */
+                    cache->key = form_key(key);
+                    break;
+                } else if ((depth == *cache->key || 255 < depth) && 0 == strcmp(key, cache->key + 1)) { /* match */
+                    break;
+                } else { /* have to move the current premature key/value deeper */
+                    unsigned char *ck   = (unsigned char *)(cache->key + depth + 1);
+                    SlotCache      orig = *cp;
+
+                    cp = (*cp)->slots + (*ck >> 4);
+                    slot_cache_new(cp);
+                    cp = (*cp)->slots + (*ck & 0x0F);
+                    slot_cache_new(cp);
+                    (*cp)->key   = cache->key;
+                    (*cp)->value = cache->value;
+                    orig->key    = form_key(key);
+                    orig->value  = Qundef;
+                }
+            } else {                   /* not exact match but on the path */
+                if (0 != cache->key) { /* there is a key/value here already */
+                    if (depth == *cache->key || (255 <= depth && 0 == strncmp(cache->key, key, depth) &&
+                                                 '\0' == cache->key[depth])) { /* key belongs here */
+                        continue;
+                    } else {
+                        unsigned char *ck   = (unsigned char *)(cache->key + depth + 1);
+                        SlotCache      orig = *cp;
+
+                        cp = (*cp)->slots + (*ck >> 4);
+                        slot_cache_new(cp);
+                        cp = (*cp)->slots + (*ck & 0x0F);
+                        slot_cache_new(cp);
+                        (*cp)->key   = cache->key;
+                        (*cp)->value = cache->value;
+                        orig->key    = 0;
+                        orig->value  = Qundef;
+                    }
+                }
+            }
+        }
+    }
+    *slot = &cache->value;
+    if (0 != keyp) {
+        if (0 == cache->key) {
+            printf("*** Error: failed to set the key for '%s'\n", key);
+            *keyp = 0;
+        } else {
+            *keyp = cache->key + 1;
+        }
+    }
+    return cache->value;
+}
+
+void slot_cache_print(SlotCache cache) {
+    /*printf("-------------------------------------------\n");*/
+    slot_print(cache, 0);
+}
+
+static void slot_print(SlotCache c, unsigned int depth) {
+    char         indent[256];
+    SlotCache   *cp;
+    unsigned int i;
+
+    if (sizeof(indent) - 1 < depth) {
+        depth = ((int)sizeof(indent) - 1);
+    }
+    memset(indent, ' ', depth);
+    indent[depth] = '\0';
+    for (i = 0, cp = c->slots; i < 16; i++, cp++) {
+        if (0 == *cp) {
+            /*printf("%s%02u:\n", indent, i);*/
+        } else {
+            if (0 == (*cp)->key && Qundef == (*cp)->value) {
+                printf("%s%02u:\n", indent, i);
+            } else {
+                const char *vs;
+                const char *clas;
+
+                if (Qundef == (*cp)->value) {
+                    vs   = "undefined";
+                    clas = "";
+                } else {
+                    VALUE rs = rb_funcall2((*cp)->value, rb_intern("to_s"), 0, 0);
+
+                    vs   = StringValuePtr(rs);
+                    clas = rb_class2name(rb_obj_class((*cp)->value));
+                }
+                printf("%s%02u: %s = %s (%s)\n", indent, i, (*cp)->key, vs, clas);
+            }
+            slot_print(*cp, depth + 2);
+        }
+    }
+}

data/ext/ox/slotcache.h

@@ -0,0 +1,19 @@
+/* slotcache.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef SLOT_CACHE_H
+#define SLOT_CACHE_H
+
+#include "ruby.h"
+
+typedef struct _slotCache   *SlotCache;
+
+extern void     slot_cache_new(SlotCache *cache);
+
+extern VALUE    slot_cache_get(SlotCache cache, const char *key, VALUE **slot, const char **keyp);
+
+extern void     slot_cache_print(SlotCache cache);
+
+#endif /* SLOT_CACHE_H */

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module.
-  VERSION = '2.14.7'
+  VERSION = '2.14.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.14.7
+  version: 2.14.10
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-04 00:00:00.000000000 Z
+date: 2022-03-10 00:00:00.000000000 Z
 dependencies: []
 description: "A fast XML parser and object serializer that uses only standard C lib.\n\nOptimized
   XML (Ox), as the name implies was written to provide speed optimized\nXML handling.
@@ -46,8 +46,6 @@ files:
 - ext/ox/obj_load.c
 - ext/ox/ox.c
 - ext/ox/ox.h
-- ext/ox/oxcache.c
-- ext/ox/oxcache.h
 - ext/ox/parse.c
 - ext/ox/sax.c
 - ext/ox/sax.h
@@ -57,6 +55,8 @@ files:
 - ext/ox/sax_hint.c
 - ext/ox/sax_hint.h
 - ext/ox/sax_stack.h
+- ext/ox/slotcache.c
+- ext/ox/slotcache.h
 - ext/ox/special.c
 - ext/ox/special.h
 - ext/ox/type.h

data/ext/ox/oxcache.c

@@ -1,160 +0,0 @@
-/* cache.c
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
-
-#include <stdlib.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-#include <stdarg.h>
-#include <stdint.h>
-
-#include "oxcache.h"
-
-struct _cache {
-    /* The key is a length byte followed by the key as a string. If the key is longer than 254 characters then the
-       length is 255. The key can be for a premature value and in that case the length byte is greater than the length
-       of the key. */
-    char                *key;
-    VALUE               value;
-    struct _cache       *slots[16];
-};
-
-static void     slot_print(Cache cache, unsigned int depth);
-
-static char* form_key(const char *s) {
-    size_t	len = strlen(s);
-    char	*d = ALLOC_N(char, len + 2);
-
-    *(uint8_t*)d = (255 <= len) ? 255 : len;
-    memcpy(d + 1, s, len + 1);
-
-    return d;
-}
-
-void
-ox_cache_new(Cache *cache) {
-    *cache = ALLOC(struct _cache);
-    (*cache)->key = 0;
-    (*cache)->value = Qundef;
-    memset((*cache)->slots, 0, sizeof((*cache)->slots));
-}
-
-VALUE
-ox_cache_get(Cache cache, const char *key, VALUE **slot, const char **keyp) {
-    unsigned char       *k = (unsigned char*)key;
-    Cache               *cp;
-
-    for (; '\0' != *k; k++) {
-        cp = cache->slots + (unsigned int)(*k >> 4); /* upper 4 bits */
-        if (0 == *cp) {
-            ox_cache_new(cp);
-        }
-        cache = *cp;
-        cp = cache->slots + (unsigned int)(*k & 0x0F); /* lower 4 bits */
-        if (0 == *cp) { /* nothing on this tree so set key and value as a premature key/value pair */
-            ox_cache_new(cp);
-            cache = *cp;
-            cache->key = form_key(key);
-            break;
-	} else {
-	    int	depth = (int)(k - (unsigned char*)key + 1);
-
-	    cache = *cp;
-
-	    if ('\0' == *(k + 1)) { /* exact match */
-		if (0 == cache->key) { /* nothing in this spot so take it */
-		    cache->key = form_key(key);
-		    break;
-		} else if ((depth == *cache->key || 255 < depth) && 0 == strcmp(key, cache->key + 1)) { /* match */
-		    break;
-		} else { /* have to move the current premature key/value deeper */
-		    unsigned char	*ck = (unsigned char*)(cache->key + depth + 1);
-                    Cache		orig = *cp;
-
-                    cp = (*cp)->slots + (*ck >> 4);
-                    ox_cache_new(cp);
-                    cp = (*cp)->slots + (*ck & 0x0F);
-                    ox_cache_new(cp);
-		    (*cp)->key = cache->key;
-		    (*cp)->value = cache->value;
-		    orig->key = form_key(key);
-		    orig->value = Qundef;
-		}
-	    } else { /* not exact match but on the path */
-		if (0 != cache->key) { /* there is a key/value here already */
-		    if (depth == *cache->key || (255 <= depth && 0 == strncmp(cache->key, key, depth) && '\0' == cache->key[depth])) { /* key belongs here */
-			continue;
-		    } else {
-			unsigned char	*ck = (unsigned char*)(cache->key + depth + 1);
-			Cache		orig = *cp;
-
-			cp = (*cp)->slots + (*ck >> 4);
-			ox_cache_new(cp);
-			cp = (*cp)->slots + (*ck & 0x0F);
-			ox_cache_new(cp);
-			(*cp)->key = cache->key;
-			(*cp)->value = cache->value;
-			orig->key = 0;
-			orig->value = Qundef;
-		    }
-		}
-	    }
-        }
-    }
-    *slot = &cache->value;
-    if (0 != keyp) {
-	if (0 == cache->key) {
-	    printf("*** Error: failed to set the key for '%s'\n", key);
-	    *keyp = 0;
-	} else {
-	    *keyp = cache->key + 1;
-	}
-    }
-    return cache->value;
-}
-
-void
-ox_cache_print(Cache cache) {
-    /*printf("-------------------------------------------\n");*/
-    slot_print(cache, 0);
-}
-
-static void
-slot_print(Cache c, unsigned int depth) {
-    char                indent[256];
-    Cache               *cp;
-    unsigned int        i;
-
-    if (sizeof(indent) - 1 < depth) {
-        depth = ((int)sizeof(indent) - 1);
-    }
-    memset(indent, ' ', depth);
-    indent[depth] = '\0';
-    for (i = 0, cp = c->slots; i < 16; i++, cp++) {
-        if (0 == *cp) {
-            /*printf("%s%02u:\n", indent, i);*/
-        } else {
-            if (0 == (*cp)->key && Qundef == (*cp)->value) {
-                printf("%s%02u:\n", indent, i);
-            } else {
-                const char      *vs;
-                const char      *clas;
-
-                if (Qundef == (*cp)->value) {
-                    vs = "undefined";
-                    clas = "";
-                } else {
-                    VALUE       rs = rb_funcall2((*cp)->value, rb_intern("to_s"), 0, 0);
-
-                    vs = StringValuePtr(rs);
-                    clas = rb_class2name(rb_obj_class((*cp)->value));
-                }
-                printf("%s%02u: %s = %s (%s)\n", indent, i, (*cp)->key, vs, clas);
-            }
-            slot_print(*cp, depth + 2);
-        }
-    }
-}

data/ext/ox/oxcache.h

@@ -1,19 +0,0 @@
-/* cache.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
-
-#ifndef OX_CACHE_H
-#define OX_CACHE_H
-
-#include "ruby.h"
-
-typedef struct _cache   *Cache;
-
-extern void     ox_cache_new(Cache *cache);
-
-extern VALUE    ox_cache_get(Cache cache, const char *key, VALUE **slot, const char **keyp);
-
-extern void     ox_cache_print(Cache cache);
-
-#endif /* OX_CACHE_H */