wordtriez 0.0.1

data/ext/hat-trie/hat-trie.h

@@ -0,0 +1,86 @@
+/*
+ * This file is part of hat-trie
+ *
+ * Copyright (c) 2011 by Daniel C. Jones <dcjones@cs.washington.edu>
+ *
+ *
+ * This is an implementation of the HAT-trie data structure described in,
+ *
+ *    Askitis, N., & Sinha, R. (2007). HAT-trie: a cache-conscious trie-based data
+ *    structure for strings. Proceedings of the thirtieth Australasian conference on
+ *    Computer science-Volume 62 (pp. 97–105). Australian Computer Society, Inc.
+ *
+ * The HAT-trie is in essence a hybrid data structure, combining tries and hash
+ * tables in a clever way to try to get the best of both worlds.
+ *
+ */
+
+#ifndef HATTRIE_HATTRIE_H
+#define HATTRIE_HATTRIE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common.h"
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct hattrie_t_ hattrie_t;
+
+hattrie_t* hattrie_create (void);             //< Create an empty hat-trie.
+void       hattrie_free   (hattrie_t*);       //< Free all memory used by a trie.
+hattrie_t* hattrie_dup    (const hattrie_t*); //< Duplicate an existing trie.
+void       hattrie_clear  (hattrie_t*);       //< Remove all entries.
+
+/** number of inserted keys
+ */
+size_t hattrie_size (hattrie_t*);
+
+/** Find the given key in the trie, inserting it if it does not exist, and
+ * returning a pointer to it's key.
+ *
+ * This pointer is not guaranteed to be valid after additional calls to
+ * hattrie_get, hattrie_del, hattrie_clear, or other functions that modifies the
+ * trie.
+ */
+value_t* hattrie_get (hattrie_t*, const char* key, size_t len);
+
+/** Find a given key in the table, returning a NULL pointer if it does not
+ * exist. */
+value_t* hattrie_tryget (hattrie_t*, const char* key, size_t len);
+
+/** hattrie_walk callback signature */
+typedef int (*hattrie_walk_cb)(const char* key, size_t len, value_t* val, void* user_data);
+
+/** hattrie_walk callback return values, controls whether should stop the walk or not */
+#define hattrie_walk_stop 0
+#define hattrie_walk_continue 1
+
+/** Find stored keys which are prefices of key, and invoke callback for every found key and val.
+ *  The invocation order is: short key to long key.
+ */
+void hattrie_walk (hattrie_t*, const char* key, size_t len, void* user_data, hattrie_walk_cb);
+
+/** Delete a given key from trie. Returns 0 if successful or -1 if not found.
+ */
+int hattrie_del(hattrie_t* T, const char* key, size_t len);
+
+typedef struct hattrie_iter_t_ hattrie_iter_t;
+
+hattrie_iter_t* hattrie_iter_begin     (const hattrie_t*, bool sorted);
+void            hattrie_iter_next      (hattrie_iter_t*);
+bool            hattrie_iter_finished  (hattrie_iter_t*);
+void            hattrie_iter_free      (hattrie_iter_t*);
+const char*     hattrie_iter_key       (hattrie_iter_t*, size_t* len);
+value_t*        hattrie_iter_val       (hattrie_iter_t*);
+
+/** Note the hattrie_iter_key() for prefixed search gets the suffix instead of the whole key
+ */
+hattrie_iter_t* hattrie_iter_with_prefix(const hattrie_t*, bool sorted, const char* prefix, size_t prefix_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/hat-trie/misc.c

@@ -0,0 +1,46 @@
+/*
+ * This file is part of hat-trie.
+ *
+ * Copyright (c) 2011 by Daniel C. Jones <dcjones@cs.washington.edu>
+ *
+ */
+
+#include "misc.h"
+#include <stdlib.h>
+
+
+void* malloc_or_die(size_t n)
+{
+    void* p = malloc(n);
+    if (p == NULL && n != 0) {
+        fprintf(stderr, "Cannot allocate %zu bytes.\n", n);
+        exit(EXIT_FAILURE);
+    }
+    return p;
+}
+
+
+void* realloc_or_die(void* ptr, size_t n)
+{
+    void* p = realloc(ptr, n);
+    if (p == NULL && n != 0) {
+        fprintf(stderr, "Cannot allocate %zu bytes.\n", n);
+        exit(EXIT_FAILURE);
+    }
+    return p;
+}
+
+
+FILE* fopen_or_die(const char* path, const char* mode)
+{
+    FILE* f = fopen(path, mode);
+    if (f == NULL) {
+        fprintf(stderr, "Cannot open file %s with mode %s.\n", path, mode);
+        exit(EXIT_FAILURE);
+    }
+    return f;
+}
+
+
+
+

data/ext/hat-trie/misc.h

@@ -0,0 +1,22 @@
+/*
+ * This file is part of hat-trie.
+ *
+ * Copyright (c) 2011 by Daniel C. Jones <dcjones@cs.washington.edu>
+ *
+ * misc :
+ * miscelaneous functions.
+ *
+ */
+
+#ifndef LINESET_MISC_H
+#define LINESET_MISC_H
+
+#include <stdio.h>
+
+void* malloc_or_die(size_t);
+void* realloc_or_die(void*, size_t);
+FILE* fopen_or_die(const char*, const char*);
+
+#endif
+
+

data/ext/hat-trie/murmurhash3.c

@@ -0,0 +1,77 @@
+/* This is MurmurHash3. The original C++ code was placed in the public domain
+ * by its author, Austin Appleby. */
+
+#include "murmurhash3.h"
+
+static inline uint32_t fmix(uint32_t h)
+{
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+
+    return h;
+}
+
+
+static inline uint32_t rotl32(uint32_t x, int8_t r)
+{
+    return (x << r) | (x >> (32 - r));
+}
+
+
+uint32_t hash(const char* data, size_t len_)
+{
+    const int len = (int) len_;
+    const int nblocks = len / 4;
+
+    uint32_t h1 = 0xc062fb4a;
+
+    uint32_t c1 = 0xcc9e2d51;
+    uint32_t c2 = 0x1b873593;
+
+    //----------
+    // body
+
+    const uint32_t * blocks = (const uint32_t*) (data + nblocks * 4);
+
+    int i;
+    for(i = -nblocks; i; i++)
+    {
+        uint32_t k1 = blocks[i];
+
+        k1 *= c1;
+        k1 = rotl32(k1, 15);
+        k1 *= c2;
+
+        h1 ^= k1;
+        h1 = rotl32(h1, 13);
+        h1 = h1*5+0xe6546b64;
+    }
+
+    //----------
+    // tail
+
+    const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+    uint32_t k1 = 0;
+
+    switch(len & 3)
+    {
+        case 3: k1 ^= tail[2] << 16;
+        case 2: k1 ^= tail[1] << 8;
+        case 1: k1 ^= tail[0];
+              k1 *= c1; k1 = rotl32(k1,15); k1 *= c2; h1 ^= k1;
+    }
+
+    //----------
+    // finalization
+
+    h1 ^= len;
+
+    h1 = fmix(h1);
+
+    return h1;
+}
+

data/ext/hat-trie/murmurhash3.h

@@ -0,0 +1,12 @@
+
+#ifndef MURMURHASH3_H
+#define MURMURHASH3_H
+
+#include <stdlib.h>
+
+#include "pstdint.h"
+
+uint32_t hash(const char* data, size_t len);
+
+#endif
+