xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/cache.c

@@ -0,0 +1,160 @@
+/* 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 "cache.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/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/cache.h

@@ -0,0 +1,19 @@
+/* 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__ */

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/cache8.c

@@ -0,0 +1,109 @@
+/* cache8.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "ruby.h"
+#include "cache8.h"
+
+#define BITS		4
+#define MASK		0x000000000000000FULL
+#define SLOT_CNT	16
+#define DEPTH		16
+
+typedef union {
+    struct _Cache8	*child;
+    slot_t		value;
+} Bucket;
+
+struct _Cache8 {
+    Bucket	buckets[SLOT_CNT];
+};
+
+static void	cache8_delete(Cache8 cache, int depth);
+//static void	slot_print(Cache8 cache, sid_t key, unsigned int depth);
+
+void
+ox_cache8_new(Cache8 *cache) {
+    Bucket	*b;
+    int		i;
+    
+    *cache = ALLOC(struct _Cache8);
+    for (i = SLOT_CNT, b = (*cache)->buckets; 0 < i; i--, b++) {
+	b->value = 0;
+    }
+}
+
+void
+ox_cache8_delete(Cache8 cache) {
+    cache8_delete(cache, 0);
+}
+
+static void
+cache8_delete(Cache8 cache, int depth) {
+    Bucket		*b;
+    unsigned int	i;
+
+    for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
+	if (0 != b->child) {
+	    if (DEPTH - 1 != depth) {
+		cache8_delete(b->child, depth + 1);
+	    }
+	}
+    }
+    xfree(cache);
+}
+
+slot_t
+ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot) {
+    Bucket	*b;
+    int		i;
+    sid_t	k8 = (sid_t)key;
+    sid_t	k;
+    
+    for (i = 64 - BITS; 0 < i; i -= BITS) {
+	k = (k8 >> i) & MASK;
+	b = cache->buckets + k;
+	if (0 == b->child) {
+	    ox_cache8_new(&b->child);
+	}
+	cache = b->child;
+    }
+    *slot = &(cache->buckets + (k8 & MASK))->value;
+
+    return **slot;
+}
+
+#if 0
+void
+ox_cache8_print(Cache8 cache) {
+    //printf("-------------------------------------------\n");
+    slot_print(cache, 0, 0);
+}
+
+static void
+slot_print(Cache8 c, sid_t key, unsigned int depth) {
+    Bucket		*b;
+    unsigned int	i;
+    sid_t		k8 = (sid_t)key;
+    sid_t		k;
+
+    for (i = 0, b = c->buckets; i < SLOT_CNT; i++, b++) {
+	if (0 != b->child) {
+	    k = (k8 << BITS) | i;
+	    //printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i);
+	    if (DEPTH - 1 == depth) {
+		printf("0x%016llx: %4llu\n", (unsigned long long)k, (unsigned long long)b->value);
+	    } else {
+		slot_print(b->child, k, depth + 1);
+	    }
+	}
+    }
+}
+#endif

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/cache8.h

@@ -0,0 +1,23 @@
+/* cache8.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OX_CACHE8_H__
+#define __OX_CACHE8_H__
+
+#include "ruby.h"
+#include "stdint.h"
+
+typedef struct _Cache8	*Cache8;
+typedef uint64_t	slot_t;
+typedef uint64_t	sid_t;
+
+extern void	ox_cache8_new(Cache8 *cache);
+extern void	ox_cache8_delete(Cache8 cache);
+
+extern slot_t	ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot);
+
+//extern void	ox_cache8_print(Cache8 cache);
+
+#endif /* __OX_CACHE8_H__ */