iodine 0.4.14 → 0.4.15

data/ext/iodine/fiobj_hash.h

@@ -0,0 +1,128 @@
+#ifndef H_FIOBJ_HASH_H
+#define H_FIOBJ_HASH_H
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+*/
+
+#include "fiobj_str.h"
+#include "fiobj_sym.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* MUST be a power of 2 */
+#define HASH_INITIAL_CAPACITY 16
+
+#include <errno.h>
+
+/** attempts to rehash the hashmap. */
+void fiobj_hash_rehash(fiobj_s *h);
+
+/* *****************************************************************************
+Couplets API - the Key-Value pair, created by the Hash object
+***************************************************************************** */
+
+/** Couplet type identifier. */
+extern const uintptr_t FIOBJ_T_COUPLET;
+
+/**
+ * If object is a Hash couplet (occurs in `fiobj_each2`), returns the key
+ * (Symbol) from the key-value pair.
+ *
+ * Otherwise returns NULL.
+ */
+fiobj_s *fiobj_couplet2key(const fiobj_s *obj);
+
+/**
+ * If object is a Hash couplet (occurs in `fiobj_each2`), returns the object
+ * (the value) from the key-value pair.
+ *
+ * Otherwise returns NULL.
+ */
+fiobj_s *fiobj_couplet2obj(const fiobj_s *obj);
+
+/* *****************************************************************************
+Hash API
+***************************************************************************** */
+
+/** Hash type identifier.
+
+The facil.io Hash object is, by default, an insecure (non-collision resistant)
+ordered Hash Table implementation.
+
+By being non-collision resistant (comparing only the Hash data), memory
+comparison can be avoided and performance increased.
+
+By being ordered it's possible to iterate over key-value pairs in the order in
+which they were added to the Hash table, making it possible to output JSON in a
+controlled manner.
+*/
+extern const uintptr_t FIOBJ_T_HASH;
+
+/**
+ * Creates a mutable empty Hash object. Use `fiobj_free` when done.
+ *
+ * Notice that these Hash objects are optimized for smaller collections and
+ * retain order of object insertion.
+ */
+fiobj_s *fiobj_hash_new(void);
+
+/** Returns the number of elements in the Hash. */
+size_t fiobj_hash_count(const fiobj_s *hash);
+
+/**
+ * Sets a key-value pair in the Hash, duplicating the Symbol and **moving**
+ * the ownership of the object to the Hash.
+ *
+ * Returns -1 on error.
+ */
+int fiobj_hash_set(fiobj_s *hash, fiobj_s *sym, fiobj_s *obj);
+
+/**
+ * Removes a key-value pair from the Hash, if it exists, returning the old
+ * object (instead of freeing it).
+ */
+fiobj_s *fiobj_hash_remove(fiobj_s *hash, fiobj_s *sym);
+
+/**
+ * Deletes a key-value pair from the Hash, if it exists, freeing the
+ * associated object.
+ *
+ * Returns -1 on type error or if the object never existed.
+ */
+int fiobj_hash_delete(fiobj_s *hash, fiobj_s *sym);
+
+/**
+ * Returns a temporary handle to the object associated with the Symbol, NULL
+ * if none.
+ */
+fiobj_s *fiobj_hash_get(const fiobj_s *hash, fiobj_s *sym);
+
+/**
+ * Returns a temporary handle to the object associated with the Symbol C string.
+ *
+ * This function takes a C string instead of a Symbol, which is slower if a
+ * Symbol can be cached but faster if a Symbol must be created.
+ *
+ * Returns NULL if no object is asociated with this String data.
+ */
+fiobj_s *fiobj_hash_get2(const fiobj_s *hash, const char *str, size_t len);
+
+/**
+ * Returns 1 if the key (Symbol) exists in the Hash, even if it's value is NULL.
+ */
+int fiobj_hash_haskey(const fiobj_s *hash, fiobj_s *sym);
+
+/**
+ * Returns a temporary theoretical Hash map capacity.
+ * This could be used for testig performance and memory consumption.
+ */
+size_t fiobj_hash_capa(const fiobj_s *hash);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/ext/iodine/fiobj_internal.c

@@ -0,0 +1,189 @@
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+*/
+#include "fiobj_internal.h"
+
+#include <errno.h>
+#include <math.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+/* *****************************************************************************
+Internal API required across the board
+***************************************************************************** */
+
+void fiobj_simple_dealloc(fiobj_s *o) { fiobj_dealloc(o); }
+
+void fiobj_noop_free(fiobj_s *obj) { OBJ2HEAD(obj)->ref = (uintptr_t)-1; }
+
+int fiobj_noop_true(const fiobj_s *obj) {
+  return 1;
+  (void)obj;
+}
+int fiobj_noop_false(const fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+fio_cstr_s fiobj_noop_str(const fiobj_s *obj) {
+  return (fio_cstr_s){.length = 0, .data = ""};
+  (void)obj;
+}
+int64_t fiobj_noop_i(const fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+double fiobj_noop_f(const fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+
+/** always 0. */
+int fiobj_noop_is_eq(const fiobj_s *self, const fiobj_s *other) {
+  return 0;
+  (void)self;
+  (void)other;
+}
+
+size_t fiobj_noop_count(const fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+fiobj_s *fiobj_noop_unwrap(const fiobj_s *obj) {
+  return (fiobj_s *)obj;
+  (void)obj;
+}
+size_t fiobj_noop_each1(fiobj_s *obj, size_t start_at,
+                        int (*task)(fiobj_s *obj, void *arg), void *arg) {
+  return 0;
+  (void)obj;
+  (void)start_at;
+  (void)task;
+  (void)arg;
+}
+
+/* *****************************************************************************
+Invalid Object VTable - unused, still considering...
+***************************************************************************** */
+
+// static void fiobj_noop_free_invalid(fiobj_s *obj) { (void)obj; }
+// static int64_t fiobj_noop_i_invalid(const fiobj_s *obj) {
+//   return ((int64_t)(obj) ^ 3);
+// }
+// struct fiobj_vtable_s FIOBJ_VTABLE_INVALID = {
+//     .name = "Invalid Class - not a facil.io Object",
+//     .free = fiobj_noop_free_invalid,
+//     .is_true = fiobj_noop_false,
+//     .to_str = fiobj_noop_str,
+//     .to_i = fiobj_noop_i_invalid,
+//     .to_f = fiobj_noop_f,
+//     .is_eq = fiobj_noop_is_eq,
+//     .count = fiobj_noop_count,
+//     .unwrap = fiobj_noop_unwrap,
+//     .each1 = fiobj_noop_each1,
+// };
+
+/* *****************************************************************************
+Internal API required across the board
+***************************************************************************** */
+
+/* *****************************************************************************
+Hashing (SipHash copy)
+***************************************************************************** */
+
+#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) &&                 \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+/* the algorithm was designed as little endian... so, byte swap 64 bit. */
+#define sip_local64(i)                                                         \
+  (((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                            \
+      (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |                 \
+      (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |         \
+      (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56)
+#else
+/* no need */
+#define sip_local64(i) (i)
+#endif
+
+/* 64Bit left rotation, inlined. */
+#define lrot64(i, bits)                                                        \
+  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
+
+uint64_t fiobj_sym_hash(const void *data, size_t len) {
+  /* initialize the 4 words */
+  uint64_t v0 = (0x0706050403020100ULL ^ 0x736f6d6570736575ULL);
+  uint64_t v1 = (0x0f0e0d0c0b0a0908ULL ^ 0x646f72616e646f6dULL);
+  uint64_t v2 = (0x0706050403020100ULL ^ 0x6c7967656e657261ULL);
+  uint64_t v3 = (0x0f0e0d0c0b0a0908ULL ^ 0x7465646279746573ULL);
+  const uint64_t *w64 = data;
+  uint8_t len_mod = len & 255;
+  union {
+    uint64_t i;
+    uint8_t str[8];
+  } word;
+
+#define hash_map_SipRound                                                      \
+  do {                                                                         \
+    v2 += v3;                                                                  \
+    v3 = lrot64(v3, 16) ^ v2;                                                  \
+    v0 += v1;                                                                  \
+    v1 = lrot64(v1, 13) ^ v0;                                                  \
+    v0 = lrot64(v0, 32);                                                       \
+    v2 += v1;                                                                  \
+    v0 += v3;                                                                  \
+    v1 = lrot64(v1, 17) ^ v2;                                                  \
+    v3 = lrot64(v3, 21) ^ v0;                                                  \
+    v2 = lrot64(v2, 32);                                                       \
+  } while (0);
+
+  while (len >= 8) {
+    word.i = sip_local64(*w64);
+    v3 ^= word.i;
+    /* Sip Rounds */
+    hash_map_SipRound;
+    hash_map_SipRound;
+    v0 ^= word.i;
+    w64 += 1;
+    len -= 8;
+  }
+  word.i = 0;
+  uint8_t *pos = word.str;
+  uint8_t *w8 = (void *)w64;
+  switch (len) { /* fallthrough is intentional */
+  case 7:
+    pos[6] = w8[6];
+  case 6:
+    pos[5] = w8[5];
+  case 5:
+    pos[4] = w8[4];
+  case 4:
+    pos[3] = w8[3];
+  case 3:
+    pos[2] = w8[2];
+  case 2:
+    pos[1] = w8[1];
+  case 1:
+    pos[0] = w8[0];
+  }
+  word.str[7] = len_mod;
+
+  /* last round */
+  v3 ^= word.i;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  v0 ^= word.i;
+  /* Finalization */
+  v2 ^= 0xff;
+  /* d iterations of SipRound */
+  hash_map_SipRound;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  /* XOR it all together */
+  v0 ^= v1 ^ v2 ^ v3;
+#undef hash_map_SipRound
+  return v0;
+}

data/ext/iodine/{fiobj_types.h → fiobj_internal.h}

@@ -1,23 +1,27 @@
+#ifndef FIOBJECT_INTERNAL_H
 /*
-Copyright: Boaz segev, 2017
+Copyright: Boaz Segev, 2017
 License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
 */
 
-#ifndef H_FIOBJ_TYPES_INTERNAL_H
-#define H_FIOBJ_TYPES_INTERNAL_H
+/**
+This header includes all the internal rescources / data and types required to
+create object types.
+*/
+#define FIOBJECT_INTERNAL_H
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
-#include "fiobj.h"
+#include "fiobject.h"
 
 #include <errno.h>
 #include <math.h>
 #include <signal.h>
 #include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
@@ -25,17 +29,18 @@ Feel free to copy, use and enjoy according to the license provided.
 Atomic add / subtract
 ***************************************************************************** */
 
-/* Select the correct compiler builtin method. */
-#if defined(__has_builtin)
-
-#if __has_builtin(__atomic_exchange_n)
+/* C11 Atomics are defined? */
+#if defined(__ATOMIC_RELAXED)
 #define SPN_LOCK_BUILTIN(...) __atomic_exchange_n(__VA_ARGS__, __ATOMIC_ACQ_REL)
 /** An atomic addition operation */
 #define spn_add(...) __atomic_add_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
 /** An atomic subtraction operation */
 #define spn_sub(...) __atomic_sub_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
 
-#elif __has_builtin(__sync_fetch_and_or)
+/* Select the correct compiler builtin method. */
+#elif defined(__has_builtin)
+
+#if __has_builtin(__sync_fetch_and_or)
 #define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
 /** An atomic addition operation */
 #define spn_add(...) __sync_add_and_fetch(__VA_ARGS__)
@@ -64,7 +69,7 @@ Simple List - Used for fiobj_s * objects, but can be used for anything really.
 typedef struct fio_ls_s {
   struct fio_ls_s *prev;
   struct fio_ls_s *next;
-  fiobj_s *obj;
+  const fiobj_s *obj;
 } fio_ls_s;
 
 #define FIO_LS_INIT(name)                                                      \
@@ -72,7 +77,7 @@ typedef struct fio_ls_s {
 
 /** Adds an object to the list's head. */
 static inline __attribute__((unused)) void fio_ls_push(fio_ls_s *pos,
-                                                       fiobj_s *obj) {
+                                                       const fiobj_s *obj) {
   /* prepare item */
   fio_ls_s *item = (fio_ls_s *)malloc(sizeof(*item));
   if (!item)
@@ -85,7 +90,7 @@ static inline __attribute__((unused)) void fio_ls_push(fio_ls_s *pos,
 
 /** Adds an object to the list's tail. */
 static inline __attribute__((unused)) void fio_ls_unshift(fio_ls_s *pos,
-                                                          fiobj_s *obj) {
+                                                          const fiobj_s *obj) {
   pos = pos->prev;
   fio_ls_push(pos, obj);
 }
@@ -95,11 +100,11 @@ static inline __attribute__((unused)) fiobj_s *fio_ls_pop(fio_ls_s *list) {
   if (list->next == list)
     return NULL;
   fio_ls_s *item = list->next;
-  fiobj_s *ret = item->obj;
+  const fiobj_s *ret = item->obj;
   list->next = item->next;
   list->next->prev = list;
   free(item);
-  return ret;
+  return (fiobj_s *)ret;
 }
 
 /** Removes an object from the list's tail. */
@@ -107,20 +112,20 @@ static inline __attribute__((unused)) fiobj_s *fio_ls_shift(fio_ls_s *list) {
   if (list->prev == list)
     return NULL;
   fio_ls_s *item = list->prev;
-  fiobj_s *ret = item->obj;
+  const fiobj_s *ret = item->obj;
   list->prev = item->prev;
   list->prev->next = list;
   free(item);
-  return ret;
+  return (fiobj_s *)ret;
 }
 
 /** Removes an object from the containing node. */
 static inline __attribute__((unused)) fiobj_s *fio_ls_remove(fio_ls_s *node) {
-  fiobj_s *ret = node->obj;
+  const fiobj_s *ret = node->obj;
   node->next->prev = node->prev->next;
   node->prev->next = node->next->prev;
   free(node);
-  return ret;
+  return (fiobj_s *)ret;
 }
 
 /* *****************************************************************************
@@ -145,146 +150,131 @@ size_t __attribute__((weak)) fiobj_memory_page_size(void) {
 #define fiobj_memory_page_size() 4096
 
 #endif
-/* *****************************************************************************
-Object types
-***************************************************************************** */
-
-/* Number */
-typedef struct {
-  fiobj_type_en type;
-  int64_t i;
-} fio_num_s;
-
-/* Float */
-typedef struct {
-  fiobj_type_en type;
-  double f;
-} fio_float_s;
-
-/* String */
-typedef struct {
-  fiobj_type_en type;
-  uint64_t capa;
-  uint64_t len;
-  uint8_t is_static;
-  char *str;
-} fio_str_s;
-
-/* Symbol */
-typedef struct {
-  fiobj_type_en type;
-  uintptr_t hash;
-  uint64_t len;
-  char str[];
-} fio_sym_s;
-
-/* IO */
-typedef struct {
-  fiobj_type_en type;
-  intptr_t fd;
-} fio_io_s;
-
-/* Array */
-typedef struct {
-  fiobj_type_en type;
-  uint64_t start;
-  uint64_t end;
-  uint64_t capa;
-  fiobj_s **arry;
-} fio_ary_s;
-
-/* *****************************************************************************
-Hash types
-***************************************************************************** */
-/* MUST be a power of 2 */
-#define FIOBJ_HASH_MAX_MAP_SEEK (256)
-
-typedef struct {
-  uintptr_t hash;
-  fio_ls_s *container;
-} map_info_s;
-
-typedef struct {
-  uintptr_t capa;
-  map_info_s *data;
-} fio_map_s;
-
-typedef struct {
-  fiobj_type_en type;
-  uintptr_t count;
-  uintptr_t mask;
-  fio_ls_s items;
-  fio_map_s map;
-} fio_hash_s;
-
-/* Hash node */
-typedef struct {
-  fiobj_type_en type;
-  fiobj_s *name;
-  fiobj_s *obj;
-} fio_couplet_s;
-
-void fiobj_hash_rehash(fiobj_s *h);
 
 /* *****************************************************************************
 Type VTable (virtual function table)
 ***************************************************************************** */
+
+/**
+ * Each type must define a complete virtual function table and point to the
+ * table from it's topmost element in it's `struct`.
+ */
 struct fiobj_vtable_s {
-  /* deallocate an object */
-  void (*free)(fiobj_s *);
-  /* object value as String */
-  fio_cstr_s (*to_str)(fiobj_s *);
-  /* object value as Integer */
-  int64_t (*to_i)(fiobj_s *);
-  /* object value as Float */
-  double (*to_f)(fiobj_s *);
-  /* true if object is equal. nested objects must be ignored (test container) */
-  int (*is_eq)(fiobj_s *self, fiobj_s *other);
-  /* return the number of nested object */
-  size_t (*count)(fiobj_s *);
-  /* perform a task for the object's children (-1 stops iteration)
+  /** class name as a C string */
+  const char *name;
+  /** deallocate an object - should deallocate parent only
+   *
+   * Note that nested objects, such as contained by Arrays and Hash maps, are
+   * handled using `each1` and handled accoring to their reference count.
+   */
+  void (*const free)(fiobj_s *);
+  /** object should evaluate as true/false? */
+  int (*const is_true)(const fiobj_s *);
+  /** object value as String */
+  fio_cstr_s (*const to_str)(const fiobj_s *);
+  /** object value as Integer */
+  int64_t (*const to_i)(const fiobj_s *);
+  /** object value as Float */
+  double (*const to_f)(const fiobj_s *);
+  /**
+   * returns 1 if objects are equal, 0 if unequal.
+   *
+   * `self` and `other` are never NULL.
+   *
+   * objects that enumerate (`count > 0`) should only test
+   * themselves (not their children). any nested objects will be tested
+   * seperately.
+   *
+   * wrapping objects should forward the function call to the wrapped objectd
+   * (similar to `count` and `each1`) after completing any internal testing.
+   */
+  int (*const is_eq)(const fiobj_s *self, const fiobj_s *other);
+  /**
+   * return the number of nested object
+   *
+   * wrapping objects should forward the function call to the wrapped objectd
+   * (similar to `each1`).
+   */
+  size_t (*const count)(const fiobj_s *o);
+  /**
+   * return either `self` or a wrapped object.
+   * (if object wrapping exists, i.e. Hash couplet, return nested object)
+   */
+  fiobj_s *(*const unwrap)(const fiobj_s *obj);
+  /**
+   * perform a task for the object's children (-1 stops iteration)
    * returns the number of items processed + `start_at`.
+   *
+   * wrapping objects should forward the function call to the wrapped objectd
+   * (similar to `count`).
    */
-  size_t (*each1)(fiobj_s *, size_t start_at,
-                  int (*task)(fiobj_s *obj, void *arg), void *arg);
+  size_t (*const each1)(fiobj_s *, size_t start_at,
+                        int (*task)(fiobj_s *obj, void *arg), void *arg);
 };
 
-fio_cstr_s fiobj_noop_str(fiobj_s *obj);
-int64_t fiobj_noop_i(fiobj_s *obj);
-double fiobj_noop_f(fiobj_s *obj);
-size_t fiobj_noop_count(fiobj_s *obj);
+// extern struct fiobj_vtable_s FIOBJ_VTABLE_INVALID; // unused just yet
+/* *****************************************************************************
+VTable (virtual function table) common implememntations
+***************************************************************************** */
+
+/** simple deallocation (`free`). */
+void fiobj_simple_dealloc(fiobj_s *o);
+/** no deallocation (eternal objects). */
+void fiobj_noop_free(fiobj_s *obj);
+/** always true. */
+int fiobj_noop_true(const fiobj_s *obj);
+/** always false. */
+int fiobj_noop_false(const fiobj_s *obj);
+/** NULL C string. */
+fio_cstr_s fiobj_noop_str(const fiobj_s *obj);
+/** always 0. */
+int64_t fiobj_noop_i(const fiobj_s *obj);
+/** always 0. */
+double fiobj_noop_f(const fiobj_s *obj);
+/** always 0. */
+size_t fiobj_noop_count(const fiobj_s *obj);
+/** always 0. */
+int fiobj_noop_is_eq(const fiobj_s *self, const fiobj_s *other);
+/** always self. */
+fiobj_s *fiobj_noop_unwrap(const fiobj_s *obj);
+/** always 0. */
 size_t fiobj_noop_each1(fiobj_s *obj, size_t start_at,
                         int (*task)(fiobj_s *obj, void *arg), void *arg);
-void fiobj_simple_dealloc(fiobj_s *o);
 
 /* *****************************************************************************
 The Object type head and management
 ***************************************************************************** */
 
-typedef struct {
-  uint64_t ref;
-  struct fiobj_vtable_s *vtable;
-} fiobj_head_s;
+typedef struct { uintptr_t ref; } fiobj_head_s;
 
-#define OBJ2HEAD(o) (((fiobj_head_s *)(o)) - 1)[0]
+#define OBJ2HEAD(o) (((fiobj_head_s *)(o)) - 1)
 #define HEAD2OBJ(o) ((fiobj_s *)(((fiobj_head_s *)(o)) + 1))
 
-#define OBJREF_ADD(o) spn_add(&OBJ2HEAD((o)).ref, 1)
-#define OBJREF_REM(o) spn_sub(&OBJ2HEAD((o)).ref, 1)
+#define OBJREF_ADD(o) spn_add(&(OBJ2HEAD((o))->ref), 1)
+#define OBJREF_REM(o) spn_sub(&(OBJ2HEAD((o))->ref), 1)
+
+#define OBJVTBL(o) ((struct fiobj_vtable_s *)(((fiobj_s *)(o))->type))
 
-#define obj2io(o) ((fio_io_s *)(o))
-#define obj2ary(o) ((fio_ary_s *)(o))
-#define obj2str(o) ((fio_str_s *)(o))
-#define obj2sym(o) ((fio_sym_s *)(o))
-#define obj2num(o) ((fio_num_s *)(o))
-#define obj2hash(o) ((fio_hash_s *)(o))
-#define obj2float(o) ((fio_float_s *)(o))
-#define obj2couplet(o) ((fio_couplet_s *)(o))
+// #define PTR2OBJ(o) (((o) << 1) | 1)
+// #define OBJ2PTR(o) (((o)&1) ? ((o) >> 1) : (o))
 
 /* *****************************************************************************
 Internal API required across the board
 ***************************************************************************** */
-void fiobj_dealloc(fiobj_s *obj);
+
+/** Allocates memory for the fiobj_s's data structure */
+static inline fiobj_s *fiobj_alloc(size_t size) {
+  fiobj_head_s *head = (fiobj_head_s *)malloc(size + sizeof(head));
+  if (!head)
+    return NULL;
+  *head = (fiobj_head_s){.ref = 1};
+  return HEAD2OBJ(head);
+};
+
+/** Deallocates the fiobj_s's data structure. */
+static inline void fiobj_dealloc(fiobj_s *obj) { free(OBJ2HEAD(obj)); }
+
+/** The Hashing function used by dynamic facil.io objects. */
 uint64_t fiobj_sym_hash(const void *data, size_t len);
 
 #endif