iodine 0.4.19 → 0.5.0

data/ext/iodine/fiobj_str.h

@@ -1,6 +1,6 @@
 #ifndef H_FIOBJ_STR_H
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 #define H_FIOBJ_STR_H
@@ -11,27 +11,20 @@ License: MIT
 extern "C" {
 #endif
 
-/** String type identifier */
-extern const uintptr_t FIOBJ_T_STRING;
-
-/** Static String type identifier */
-extern const uintptr_t FIOBJ_T_STRING_STATIC;
-
-#define FIOBJ_IS_STRING(obj)                                                   \
-  (obj->type == FIOBJ_T_STRING || obj->type == FIOBJ_T_STRING_STATIC)
+#define FIOBJ_IS_STRING(obj) FIOBJ_TYPE_IS((obj), FIOBJ_T_STRING)
 
 /* *****************************************************************************
-String API
+API: Creating a String Object
 ***************************************************************************** */
 
 /** Creates a String object. Remember to use `fiobj_free`. */
-fiobj_s *fiobj_str_new(const char *str, size_t len);
+FIOBJ fiobj_str_new(const char *str, size_t len);
 
 /** Creates a buffer String object. capa includes NUL.
  *
  * Remember to use `fiobj_free`.
  */
-fiobj_s *fiobj_str_buf(size_t capa);
+FIOBJ fiobj_str_buf(size_t capa);
 
 /**
  * Creates a static String object from a static C string. Remember `fiobj_free`.
@@ -43,68 +36,124 @@ fiobj_s *fiobj_str_buf(size_t capa);
  *
  * NOTICE: static strings can't be written to.
  */
-fiobj_s *fiobj_str_static(const char *str, size_t len);
+FIOBJ fiobj_str_static(const char *str, size_t len);
 
 /** Creates a copy from an existing String. Remember to use `fiobj_free`. */
-fiobj_s *fiobj_str_copy(fiobj_s *src);
+static inline __attribute__((unused)) FIOBJ fiobj_str_copy(FIOBJ src) {
+  fio_cstr_s s = fiobj_obj2cstr(src);
+  return fiobj_str_new(s.data, s.len);
+}
+
+/**
+ * Creates a String object. Remember to use `fiobj_free`.
+ *
+ * The ownership of the memory indicated by `str` will now "move" to the object.
+ *
+ * The original memory MUST be allocated using `fio_malloc` (NOT the system's
+ * `malloc`) and it will be freed by the `fiobj` library using `fio_free`.
+ */
+FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity);
+
+/**
+ * Returns a thread-static temporary string. Avoid calling `fiobj_dup` or
+ * `fiobj_free`.
+ */
+FIOBJ fiobj_str_tmp(void);
 
 /** Creates a String object using a printf like interface. */
-__attribute__((format(printf, 1, 0))) fiobj_s *
-fiobj_strvprintf(const char *format, va_list argv);
+__attribute__((format(printf, 1, 0))) FIOBJ fiobj_strvprintf(const char *format,
+                                                             va_list argv);
 
 /** Creates a String object using a printf like interface. */
-__attribute__((format(printf, 1, 2))) fiobj_s *
-fiobj_strprintf(const char *format, ...);
+__attribute__((format(printf, 1, 2))) FIOBJ fiobj_strprintf(const char *format,
+                                                            ...);
 
 /** Dumps the `filename` file's contents into a new String. If `limit == 0`,
  * than the data will be read until EOF.
  *
- * If the file can't be located, opened or read, or if `start_at` is beyond the
- * EOF position, NULL is returned.
+ * If the file can't be located, opened or read, or if `start_at` is out of
+ * bounds (i.e., beyond the EOF position), FIOBJ_INVALID is returned.
+ *
+ * If `start_at` is negative, it will be computed from the end of the file.
  *
  * Remember to use `fiobj_free`.
  *
- * NOTE: Requires a UNIX system, otherwise always returns NULL.
+ * NOTE: Requires a UNIX system, otherwise always returns FIOBJ_INVALID.
+ */
+FIOBJ fiobj_str_readfile(const char *filename, intptr_t start_at,
+                         intptr_t limit);
+
+/* *****************************************************************************
+API: Editing a String
+***************************************************************************** */
+
+/**
+ * Prevents the String object from being changed.
+ *
+ * When a String is used as a key for a Hash, it is automatically frozenn to
+ * prevent the Hash from becoming broken.
+ *
+ * A call to `fiobj_str_hash` or `fiobj_obj2hash` will automactically freeze the
+ * String.
  */
-fiobj_s *fiobj_str_readfile(const char *filename, size_t start_at,
-                            size_t limit);
+void fiobj_str_freeze(FIOBJ str);
+
 /**
  * Confirms the requested capacity is available and allocates as required.
  *
  * Returns updated capacity.
  */
-size_t fiobj_str_capa_assert(fiobj_s *str, size_t size);
+size_t fiobj_str_capa_assert(FIOBJ str, size_t size);
 
 /** Return's a String's capacity, if any. This should include the NUL byte. */
-size_t fiobj_str_capa(fiobj_s *str);
+size_t fiobj_str_capa(FIOBJ str);
 
 /** Resizes a String object, allocating more memory if required. */
-void fiobj_str_resize(fiobj_s *str, size_t size);
+void fiobj_str_resize(FIOBJ str, size_t size);
 
 /** Deallocates any unnecessary memory (if supported by OS). */
-void fiobj_str_minimize(fiobj_s *str);
+void fiobj_str_minimize(FIOBJ str);
 
 /** Empties a String's data. */
-void fiobj_str_clear(fiobj_s *str);
+void fiobj_str_clear(FIOBJ str);
 
 /**
  * Writes data at the end of the string, resizing the string as required.
  * Returns the new length of the String
  */
-size_t fiobj_str_write(fiobj_s *dest, const char *data, size_t len);
+size_t fiobj_str_write(FIOBJ dest, const char *data, size_t len);
 
 /**
  * Writes data at the end of the string, resizing the string as required.
  * Returns the new length of the String
  */
 __attribute__((format(printf, 2, 3))) size_t
-fiobj_str_write2(fiobj_s *dest, const char *format, ...);
+fiobj_str_write2(FIOBJ dest, const char *format, ...);
 
 /**
  * Writes data at the end of the string, resizing the string as required.
- * Returns the new length of the String
+ *
+ * Remember to call `fiobj_free` to free the source (when done with it).
+ *
+ * Returns the new length of the String.
+ */
+size_t fiobj_str_join(FIOBJ dest, FIOBJ source);
+
+/* *****************************************************************************
+API: String Values
+***************************************************************************** */
+
+/**
+ * Calculates a String's SipHash value for possible use as a HashMap key.
+ *
+ * Hashing the String's value automatically freezes the string, preventing
+ * future changes.
  */
-size_t fiobj_str_join(fiobj_s *dest, fiobj_s *obj);
+uint64_t fiobj_str_hash(FIOBJ o);
+
+#if DEBUG
+void fiobj_test_string(void);
+#endif
 
 #ifdef __cplusplus
 } /* extern "C" */

data/ext/iodine/fiobject.c

@@ -1,19 +1,18 @@
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
 /**
 This facil.io core library provides wrappers around complex and (or) dynamic
 types, abstracting some complexity and making dynamic type related tasks easier.
+*/
+#include "fiobject.h"
 
+#include "fio_ary.h"
 
-The library offers a rudementry protection against cyclic references using the
-`FIOBJ_NESTING_PROTECTION` flag (i.e., nesting an Array within itself)...
-however, this isn't fully tested and the performance price is high.
-*/
-#include "fiobj_internal.h"
-#include "fiobj_primitives.h"
+#define FIO_OVERRIDE_MALLOC 1
+#include "fio_mem.h"
 
 #include <stdarg.h>
 #include <stdint.h>
@@ -21,569 +20,321 @@ however, this isn't fully tested and the performance price is high.
 #include <stdlib.h>
 
 /* *****************************************************************************
-Cyclic Protection helpers & API
+the `fiobj_each2` function
 ***************************************************************************** */
-
-static __thread fiobj_s *fiobj_cyclic_protection = NULL;
-fiobj_s *fiobj_each_get_cyclic(void) { return fiobj_cyclic_protection; }
-
-static inline fiobj_s *protected_pop_obj(fio_ls_s *queue, fio_ls_s *history) {
-#if FIOBJ_NESTING_PROTECTION
-  fiobj_cyclic_protection = NULL;
-
-  fiobj_s *obj = fio_ls_pop(queue);
-  if (!obj)
-    return NULL;
-  fiobj_s *child = OBJVTBL(obj)->unwrap(obj);
-  if (!child)
-    return obj;
-  if (OBJVTBL(child)->count(child) == 0)
-    return obj;
-  fio_ls_s *pos = history->next;
-  while (pos != history) {
-    if (child == pos->obj) {
-      fiobj_cyclic_protection = obj;
-      return NULL;
-    }
-    pos = pos->next;
+struct task_packet_s {
+  int (*task)(FIOBJ obj, void *arg);
+  void *arg;
+  fio_ary_s *stack;
+  FIOBJ next;
+  uintptr_t counter;
+  uint8_t stop;
+  uint8_t incomplete;
+};
+
+static int fiobj_task_wrapper(FIOBJ o, void *p_) {
+  struct task_packet_s *p = p_;
+  ++p->counter;
+  int ret = p->task(o, p->arg);
+  if (ret == -1) {
+    p->stop = 1;
+    return -1;
   }
-  return obj;
-#else
-  return fio_ls_pop(queue);
-  (void)history;
-#endif
-}
-
-static inline void protected_push_obj(const fiobj_s *obj, fio_ls_s *history) {
-#if FIOBJ_NESTING_PROTECTION
-  fio_ls_push(history, OBJVTBL(obj)->unwrap(obj));
-#else
-  (void)obj;
-  (void)history;
-#endif
-}
-
-/* *****************************************************************************
-Generic Object API
-***************************************************************************** */
-
-/** Returns a C string naming the objects dynamic type. */
-const char *fiobj_type_name(const fiobj_s *obj) { return OBJVTBL(obj)->name; }
-
-/**
- * Copy by reference(!) - increases an object's (and any nested object's)
- * reference count.
- *
- * Always returns the value passed along.
- *
- * Future implementations might provide `fiobj_dup2` providing a deep copy.
- *
- * We don't need this feature just yet, so I'm not working on it.
- */
-fiobj_s *fiobj_dup(fiobj_s *obj) {
-  OBJREF_ADD(obj);
-  return obj;
-}
-
-static int fiobj_free_or_mark(fiobj_s *o, void *arg) {
-  if (!o)
-    return 0;
-#if FIOBJ_NESTING_PROTECTION
-  if (OBJ2HEAD(o)->ref == 0) /* maybe a nested returning... */
-    return 0;
-#elif DEBUG
-  if (OBJ2HEAD(o)->ref == 0) {
-    fprintf(stderr,
-            "ERROR: attempting to free an object that isn't a fiobj or already "
-            "freed (%p)\n",
-            (void *)o);
-    kill(0, SIGABRT);
-  }
-#endif
-
-  if (OBJREF_REM(o))
-    return 0;
-
-  /* reference count is zero: free memory or add to queue */
-
-  /* test for wrapped object (i.e., Hash Couplet) */
-  fiobj_s *child = OBJVTBL(o)->unwrap(o);
-
-  if (child != o) {
-    if (!child || OBJREF_REM(child)) {
-      OBJVTBL(o)->free(o);
-      return 0;
-    }
-    OBJVTBL(o)->free(o);
-    o = child;
+  if (FIOBJ_IS_ALLOCATED(o) && FIOBJECT2VTBL(o)->each) {
+    p->incomplete = 1;
+    p->next = o;
+    return -1;
   }
-
-  if (OBJVTBL(o)->count(o)) {
-    fio_ls_push(arg, o);
-  } else
-    OBJVTBL(o)->free(o);
-
-  /* handle nesting / wrapping (i.e., Array, Hash, Couplets ) */
   return 0;
 }
-
-/**
- * Decreases an object's reference count, releasing memory and
- * resources.
- *
- * This function affects nested objects, meaning that when an Array or
- * a Hash object is passed along, it's children (nested objects) are
- * also freed.
- */
-void fiobj_free(fiobj_s *o) {
-#if DEBUG
-  if (!o)
-    return;
-  if (OBJ2HEAD(o)->ref == 0) {
-    fprintf(stderr,
-            "ERROR: attempting to free an object that isn't a fiobj or already "
-            "freed (%p)\n",
-            (void *)o);
-    kill(0, SIGABRT);
-  }
-#endif
-  if (!o || OBJREF_REM(o))
-    return;
-
-  /* handle wrapping */
-  {
-    fiobj_s *child = OBJVTBL(o)->unwrap(o);
-    if (child != o) {
-      OBJVTBL(o)->free(o);
-      if (OBJREF_REM(child))
-        return;
-      o = child;
-    }
-  }
-  if (OBJVTBL(o)->count(o) == 0) {
-    OBJVTBL(o)->free(o);
-    return;
-  }
-  /* nested free */
-  fio_ls_s queue = FIO_LS_INIT(queue);
-  fio_ls_s history = FIO_LS_INIT(history);
-  while (o) {
-    /* the queue always contains valid enumerable objects that are unwrapped. */
-    OBJVTBL(o)->each1(o, 0, fiobj_free_or_mark, &queue);
-    fio_ls_push(&history, o);
-    o = protected_pop_obj(&queue, &history);
-  }
-  /* clean up and free enumerables */
-  while ((o = fio_ls_pop(&history)))
-    OBJVTBL(o)->free(o);
-  return;
-}
-
-/**
- * Attempts to return the object's current reference count.
- *
- * This is mostly for testing rather than normal library operations.
- */
-uintptr_t fiobj_reference_count(const fiobj_s *o) { return OBJ2HEAD(o)->ref; }
-
-/**
- * Tests if an object evaluates as TRUE.
- *
- * This is object type specific. For example, empty strings might evaluate as
- * FALSE, even though they aren't a boolean type.
- */
-int fiobj_is_true(const fiobj_s *o) { return (o && OBJVTBL(o)->is_true(o)); }
-
-/**
- * Returns an Object's numerical value.
- *
- * If a String or Symbol are passed to the function, they will be
- * parsed assuming base 10 numerical data.
- *
- * Hashes and Arrays return their object count.
- *
- * IO and File objects return their underlying file descriptor.
- *
- * A type error results in 0.
- */
-int64_t fiobj_obj2num(const fiobj_s *o) { return o ? OBJVTBL(o)->to_i(o) : 0; }
-
-/**
- * Returns a Float's value.
- *
- * If a String or Symbol are passed to the function, they will be
- * parsed assuming base 10 numerical data.
- *
- * Hashes and Arrays return their object count.
- *
- * IO and File objects return their underlying file descriptor.
- *
- * A type error results in 0.
- */
-double fiobj_obj2float(const fiobj_s *o) { return o ? OBJVTBL(o)->to_f(o) : 0; }
-
-/**
- * Returns a C String (NUL terminated) using the `fio_cstr_s` data type.
- *
- * The Sting in binary safe and might contain NUL bytes in the middle as well as
- * a terminating NUL.
- *
- * If a Symbol, a Number or a Float are passed to the function, they
- * will be parsed as a *temporary*, thread-safe, String.
- *
- * Numbers will be represented in base 10 numerical data.
- *
- * A type error results in NULL (i.e. object isn't a String).
- */
-fio_cstr_s fiobj_obj2cstr(const fiobj_s *o) {
-  return o ? OBJVTBL(o)->to_str(o) : fiobj_noop_str(NULL);
-}
-
 /**
  * Single layer iteration using a callback for each nested fio object.
  *
- * Accepts any `fiobj_s *` type but only collections (Arrays and Hashes) are
+ * Accepts any `FIOBJ ` type but only collections (Arrays and Hashes) are
  * processed. The container itself (the Array or the Hash) is **not** processed
  * (unlike `fiobj_each2`).
  *
  * The callback task function must accept an object and an opaque user pointer.
  *
  * Hash objects pass along a `FIOBJ_T_COUPLET` object, containing
- * references for both the key (Symbol) and the object (any object).
+ * references for both the key and the object. Keys shouldn't be altered once
+ * placed as a key (or the Hash will break). Collections (Arrays / Hashes) can't
+ * be used as keeys.
  *
  * If the callback returns -1, the loop is broken. Any other value is ignored.
  *
  * Returns the "stop" position, i.e., the number of items processed + the
  * starting point.
  */
-size_t fiobj_each1(fiobj_s *o, size_t start_at,
-                   int (*task)(fiobj_s *obj, void *arg), void *arg) {
-  return o ? OBJVTBL(o)->each1(o, start_at, task, arg) : 0;
-}
-
-/* *****************************************************************************
-Nested concern (each2, is_eq)
-***************************************************************************** */
-
-static int each2_add_to_queue(fiobj_s *obj, void *arg) {
-  fio_ls_s *const queue = arg;
-  fio_ls_unshift(queue, obj);
-  return 0;
-}
-
-/**
- * Deep iteration using a callback for each fio object, including the parent.
- *
- *
- * Notice that when passing collections to the function, the collection itself
- * is sent to the callback followed by it's children (if any). This is true also
- * for nested collections (a nested Hash will be sent first, followed by the
- * nested Hash's children and then followed by the rest of it's siblings.
- *
- * If the callback returns -1, the loop is broken. Any other value is ignored.
- */
-void fiobj_each2(fiobj_s *obj, int (*task)(fiobj_s *obj, void *arg),
-                 void *arg) {
-  if (!obj)
-    goto single;
-  size_t count = OBJVTBL(obj)->count(obj);
-  if (!count)
-    goto single;
-
-  fio_ls_s queue = FIO_LS_INIT(queue), history = FIO_LS_INIT(history);
-  while (obj || queue.next != &queue) {
-    int i = task(obj, arg);
-    if (i == -1)
-      goto finish;
-    if (obj && OBJVTBL(obj)->count(obj)) {
-      protected_push_obj(obj, &history);
-      OBJVTBL(obj)->each1(obj, 0, each2_add_to_queue, queue.next);
-    }
-    obj = protected_pop_obj(&queue, &history);
-  }
-finish:
-  while (fio_ls_pop(&history))
-    ;
-  while (fio_ls_pop(&queue))
-    ;
-  return;
-single:
-  task(obj, arg);
-  return;
-}
-
-/**
- * Deeply compare two objects. No hashing is involved.
- *
- * KNOWN ISSUES:
- *
- * * Cyclic nesting might cause this function to hang (much like `fiobj_each2`).
- *
- * * `FIOBJ_NESTING_PROTECTION` might be ignored when testing nested objects.
- *
- * * Hash order might be ignored when comapring Hashes, which means that equal
- *   Hases might behave differently during iteration.
- *
- */
-int fiobj_iseq(const fiobj_s *self, const fiobj_s *other) {
-  if (self == other)
+size_t fiobj_each2(FIOBJ o, int (*task)(FIOBJ obj, void *arg), void *arg) {
+  if (!o || !FIOBJ_IS_ALLOCATED(o) || (FIOBJECT2VTBL(o)->each == NULL)) {
+    task(o, arg);
     return 1;
-  if (!self)
-    return other->type == FIOBJ_T_NULL;
-  if (!other)
-    return self->type == FIOBJ_T_NULL;
-
-  if (!OBJVTBL(self)->is_eq(self, other))
-    return 0;
-  if (!OBJVTBL(self)->count(self))
+  }
+  /* run task for root object */
+  if (task(o, arg) == -1)
     return 1;
-
-  uint8_t eq = 0;
-  fio_ls_s self_queue = FIO_LS_INIT(self_queue);
-  fio_ls_s self_history = FIO_LS_INIT(self_history);
-  fio_ls_s other_queue = FIO_LS_INIT(other_queue);
-  fio_ls_s other_history = FIO_LS_INIT(other_history);
-
-  while (self) {
-    protected_push_obj(self, &self_history);
-    protected_push_obj(other, &other_history);
-    OBJVTBL(self)->each1((fiobj_s *)self, 0, each2_add_to_queue,
-                         self_queue.next);
-    OBJVTBL(other)->each1((fiobj_s *)other, 0, each2_add_to_queue,
-                          other_queue.next);
-    while (self_queue.next != &self_queue || self) {
-      self = protected_pop_obj(&self_queue, &self_history);
-      other = protected_pop_obj(&other_queue, &other_history);
-      if (self == other)
-        continue;
-      if (!self && other->type != FIOBJ_T_NULL)
-        goto finish;
-      if (!other && self->type != FIOBJ_T_NULL)
-        goto finish;
-      if (OBJVTBL(self)->count(self))
-        break;
-      if (!OBJVTBL(self)->is_eq(self, other))
-        goto finish;
-    }
-    if (self && !OBJVTBL(self)->is_eq(self, other))
+  uintptr_t pos = 0;
+  fio_ary_s stack = FIO_ARY_INIT;
+  struct task_packet_s packet = {
+      .task = task, .arg = arg, .stack = &stack, .counter = 1,
+  };
+  do {
+    if (!pos)
+      packet.next = 0;
+    packet.incomplete = 0;
+    pos = FIOBJECT2VTBL(o)->each(o, pos, fiobj_task_wrapper, &packet);
+    if (packet.stop)
       goto finish;
-  }
-  eq = 1;
+    if (packet.incomplete) {
+      fio_ary_push(&stack, (void *)pos);
+      fio_ary_push(&stack, (void *)o);
+    }
 
+    if (packet.next) {
+      fio_ary_push(&stack, (void *)0);
+      fio_ary_push(&stack, (void *)packet.next);
+    }
+    o = (FIOBJ)fio_ary_pop(&stack);
+    pos = (uintptr_t)fio_ary_pop(&stack);
+  } while (o);
 finish:
-  while (fio_ls_pop(&self_history))
-    ;
-  while (fio_ls_pop(&self_queue))
-    ;
-  while (fio_ls_pop(&other_history))
-    ;
-  while (fio_ls_pop(&other_queue))
-    ;
-  return eq;
+  fio_ary_free(&stack);
+  return packet.counter;
 }
 
 /* *****************************************************************************
-Number and Float Helpers
+Free complex objects (objects with nesting)
 ***************************************************************************** */
-static const char hex_notation[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                                    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
+static void fiobj_dealloc_task(FIOBJ o, void *stack_) {
+  // if (!o)
+  //   fprintf(stderr, "* WARN: freeing a NULL no-object\n");
+  // else
+  //   fprintf(stderr, "* freeing object %s\n", fiobj_obj2cstr(o).data);
+  if (!o || !FIOBJ_IS_ALLOCATED(o))
+    return;
+  if (OBJREF_REM(o))
+    return;
+  if (!FIOBJECT2VTBL(o)->each || !FIOBJECT2VTBL(o)->count(o)) {
+    FIOBJECT2VTBL(o)->dealloc(o, NULL, NULL);
+    return;
+  }
+  fio_ary_s *s = stack_;
+  fio_ary_push(s, (void *)o);
+}
 /**
- * A helper function that converts between String data to a signed int64_t.
+ * Decreases an object's reference count, releasing memory and
+ * resources.
  *
- * Numbers are assumed to be in base 10. `0x##` (or `x##`) and `0b##` (or
- * `b##`) are recognized as base 16 and base 2 (binary MSB first)
- * respectively.
+ * This function affects nested objects, meaning that when an Array or
+ * a Hash object is passed along, it's children (nested objects) are
+ * also freed.
  */
-int64_t fio_atol(char **pstr) {
-  char *str = *pstr;
-  uint64_t result = 0;
-  uint8_t invert = 0;
-  while (str[0] == '0')
-    str++;
-  while (str[0] == '-') {
-    invert ^= 1;
-    str++;
-  }
-  while (str[0] == '0')
-    str++;
-  if (str[0] == 'b' || str[0] == 'B') {
-    /* base 2 */
-    str++;
-    while (str[0] == '0' || str[0] == '1') {
-      result = (result << 1) | (str[0] == '1');
-      str++;
-    }
-  } else if (str[0] == 'x' || str[0] == 'X') {
-    /* base 16 */
-    uint8_t tmp;
-    str++;
-    while (1) {
-      if (str[0] >= '0' && str[0] <= '9')
-        tmp = str[0] - '0';
-      else if (str[0] >= 'A' && str[0] <= 'F')
-        tmp = str[0] - ('A' - 10);
-      else if (str[0] >= 'a' && str[0] <= 'f')
-        tmp = str[0] - ('a' - 10);
-      else
-        goto finish;
-      result = (result << 4) | tmp;
-      str++;
-    }
-  } else {
-    /* base 10 */
-    const char *end = str;
-    while (end[0] >= '0' && end[0] <= '9' && (uintptr_t)(end - str) < 22)
-      end++;
-    if ((uintptr_t)(end - str) > 21) /* too large for a number */
-      return 0;
-
-    while (str < end) {
-      result = (result * 10) + (str[0] - '0');
-      str++;
-    }
-  }
-finish:
-  if (invert)
-    result = 0 - result;
-  *pstr = str;
-  return (int64_t)result;
+void fiobj_free_complex_object(FIOBJ o) {
+  fio_ary_s stack = FIO_ARY_INIT;
+  do {
+    FIOBJECT2VTBL(o)->dealloc(o, fiobj_dealloc_task, &stack);
+  } while ((o = (FIOBJ)fio_ary_pop(&stack)));
+  fio_ary_free(&stack);
 }
 
-/** A helper function that convers between String data to a signed double. */
-double fio_atof(char **pstr) { return strtold(*pstr, pstr); }
-
 /* *****************************************************************************
-String Helpers
+Is Equal?
 ***************************************************************************** */
+#include "fiobj_hash.h"
 
-/**
- * A helper function that convers between a signed int64_t to a string.
- *
- * No overflow guard is provided, make sure there's at least 66 bytes
- * available (for base 2).
- *
- * Supports base 2, base 10 and base 16. An unsupported base will silently
- * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
- * beginning of the string).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-size_t fio_ltoa(char *dest, int64_t num, uint8_t base) {
-  if (!num) {
-    *(dest++) = '0';
-    *(dest++) = 0;
+static inline int fiobj_iseq_simple(const FIOBJ o, const FIOBJ o2) {
+  if (o == o2)
     return 1;
-  }
-
-  size_t len = 0;
+  if (!o || !o2)
+    return 0; /* they should have compared equal before. */
+  if (!FIOBJ_IS_ALLOCATED(o) || !FIOBJ_IS_ALLOCATED(o2))
+    return 0; /* they should have compared equal before. */
+  if (FIOBJECT2HEAD(o)->type != FIOBJECT2HEAD(o2)->type)
+    return 0; /* non-type equality is a barriar to equality. */
+  if (!FIOBJECT2VTBL(o)->is_eq(o, o2))
+    return 0;
+  return 1;
+}
 
-  if (base == 2) {
-    uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-    uint8_t i = 0;    /* counting bits */
+int fiobj_iseq____internal_complex__task(FIOBJ o, void *ary_) {
+  fio_ary_s *ary = ary_;
+  fio_ary_push(ary, (void *)o);
+  if (fiobj_hash_key_in_loop())
+    fio_ary_push(ary, (void *)fiobj_hash_key_in_loop());
+  return 0;
+}
 
-    while ((i < 64) && (n & 0x8000000000000000) == 0) {
-      n = n << 1;
-      i++;
-    }
-    /* make sure the Binary representation doesn't appear signed. */
-    if (i) {
-      dest[len++] = '0';
-    }
-    /* write to dest. */
-    while (i < 64) {
-      dest[len++] = ((n & 0x8000000000000000) ? '1' : '0');
-      n = n << 1;
-      i++;
+/** used internally for complext nested tests (Array / Hash types) */
+int fiobj_iseq____internal_complex__(FIOBJ o, FIOBJ o2) {
+  // if (FIOBJECT2VTBL(o)->each && FIOBJECT2VTBL(o)->count(o))
+  //   return int fiobj_iseq____internal_complex__(const FIOBJ o, const FIOBJ
+  //   o2);
+  fio_ary_s left = FIO_ARY_INIT, right = FIO_ARY_INIT, queue = FIO_ARY_INIT;
+  do {
+    fiobj_each1(o, 0, fiobj_iseq____internal_complex__task, &left);
+    fiobj_each1(o2, 0, fiobj_iseq____internal_complex__task, &right);
+    while (fio_ary_count(&left)) {
+      o = (FIOBJ)fio_ary_pop(&left);
+      o2 = (FIOBJ)fio_ary_pop(&right);
+      if (!fiobj_iseq_simple(o, o2))
+        goto unequal;
+      if (FIOBJ_IS_ALLOCATED(o) && FIOBJECT2VTBL(o)->each &&
+          FIOBJECT2VTBL(o)->count(o)) {
+        fio_ary_push(&queue, (void *)o);
+        fio_ary_push(&queue, (void *)o2);
+      }
     }
-    dest[len] = 0;
-    return len;
+    o2 = (FIOBJ)fio_ary_pop(&queue);
+    o = (FIOBJ)fio_ary_pop(&queue);
+    if (!fiobj_iseq_simple(o, o2))
+      goto unequal;
+  } while (o);
+  fio_ary_free(&left);
+  fio_ary_free(&right);
+  fio_ary_free(&queue);
+  return 1;
+unequal:
+  fio_ary_free(&left);
+  fio_ary_free(&right);
+  fio_ary_free(&queue);
+  return 0;
+}
 
-  } else if (base == 16) {
-    uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-    uint8_t i = 0;    /* counting bytes */
-    uint8_t tmp = 0;
-    while (i < 8 && (n & 0xFF00000000000000) == 0) {
-      n = n << 8;
-      i++;
-    }
-    /* make sure the Hex representation doesn't appear signed. */
-    if (i && (n & 0x8000000000000000)) {
-      dest[len++] = '0';
-      dest[len++] = '0';
-    }
-    /* write the damn thing */
-    while (i < 8) {
-      tmp = (n & 0xF000000000000000) >> 60;
-      dest[len++] = hex_notation[tmp];
-      tmp = (n & 0x0F00000000000000) >> 56;
-      dest[len++] = hex_notation[tmp];
-      i++;
-      n = n << 8;
-    }
-    dest[len] = 0;
-    return len;
-  }
+/* *****************************************************************************
+Defaults / NOOPs
+***************************************************************************** */
 
-  /* fallback to base 10 */
-  uint64_t rem = 0;
-  uint64_t factor = 1;
-  if (num < 0) {
-    dest[len++] = '-';
-    num = 0 - num;
-  }
+void fiobject___noop_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
+  (void)o;
+  (void)task;
+  (void)arg;
+}
+void fiobject___simple_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
+                               void *arg) {
+  free(FIOBJ2PTR(o));
+  (void)task;
+  (void)arg;
+}
 
-  while (num / factor)
-    factor *= 10;
+uintptr_t fiobject___noop_count(const FIOBJ o) {
+  (void)o;
+  return 0;
+}
+size_t fiobject___noop_is_eq(const FIOBJ o1, const FIOBJ o2) {
+  (void)o1;
+  (void)o2;
+  return 0;
+}
 
-  while (factor > 1) {
-    factor = factor / 10;
-    rem = (rem * 10);
-    dest[len++] = '0' + ((num / factor) - rem);
-    rem += ((num / factor) - rem);
-  }
-  dest[len] = 0;
-  return len;
+fio_cstr_s fiobject___noop_to_str(const FIOBJ o) {
+  (void)o;
+  return (fio_cstr_s){.len = 0, .data = NULL};
+}
+intptr_t fiobject___noop_to_i(const FIOBJ o) {
+  (void)o;
+  return 0;
+}
+double fiobject___noop_to_f(const FIOBJ o) {
+  (void)o;
+  return 0;
 }
 
-/**
- * A helper function that convers between a double to a string.
- *
- * No overflow guard is provided, make sure there's at least 130 bytes
- * available (for base 2).
- *
- * Supports base 2, base 10 and base 16. An unsupported base will silently
- * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
- * beginning of the string).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-size_t fio_ftoa(char *dest, double num, uint8_t base) {
-  if (base == 2 || base == 16) {
-    /* handle the binary / Hex representation the same as if it were an
-     * int64_t
-     */
-    int64_t *i = (void *)&num;
-    return fio_ltoa(dest, *i, base);
-  }
+#if DEBUG
 
-  size_t written = sprintf(dest, "%g", num);
-  uint8_t need_zero = 1;
-  char *start = dest;
-  while (*start) {
-    if (*start == ',') // locale issues?
-      *start = '.';
-    if (*start == '.' || *start == 'e') {
-      need_zero = 0;
-      break;
-    }
-    start++;
-  }
-  if (need_zero) {
-    dest[written++] = '.';
-    dest[written++] = '0';
+#include "fiobj_ary.h"
+#include "fiobj_numbers.h"
+
+static int fiobject_test_task(FIOBJ o, void *arg) {
+  ++((uintptr_t *)arg)[0];
+  if (!o)
+    fprintf(stderr, "* WARN: counting a NULL no-object\n");
+  // else
+  //   fprintf(stderr, "* counting object %s\n", fiobj_obj2cstr(o).data);
+  return 0;
+  (void)o;
+}
+
+void fiobj_test_core(void) {
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, __VA_ARGS__);                                              \
+    fprintf(stderr, "Testing failed.\n");                                      \
+    exit(-1);                                                                  \
   }
-  return written;
+  fprintf(stderr, "=== Testing Primitives\n");
+  FIOBJ o = fiobj_null();
+  TEST_ASSERT(o == (FIOBJ)FIOBJ_T_NULL, "fiobj_null isn't NULL!\n");
+  TEST_ASSERT(FIOBJ_TYPE(0) == FIOBJ_T_NULL, "NULL isn't NULL!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(0, FIOBJ_T_NULL), "NULL isn't NULL! (2)\n");
+  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_null()),
+              "fiobj_null claims to be allocated!\n");
+  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_true()),
+              "fiobj_true claims to be allocated!\n");
+  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_false()),
+              "fiobj_false claims to be allocated!\n");
+  TEST_ASSERT(FIOBJ_TYPE(fiobj_true()) == FIOBJ_T_TRUE,
+              "fiobj_true isn't FIOBJ_T_TRUE!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_true(), FIOBJ_T_TRUE),
+              "fiobj_true isn't FIOBJ_T_TRUE! (2)\n");
+  TEST_ASSERT(FIOBJ_TYPE(fiobj_false()) == FIOBJ_T_FALSE,
+              "fiobj_false isn't FIOBJ_T_TRUE!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_false(), FIOBJ_T_FALSE),
+              "fiobj_false isn't FIOBJ_T_TRUE! (2)\n");
+  fiobj_free(o); /* testing for crash*/
+  fprintf(stderr, "* passed.\n");
+  fprintf(stderr, "=== Testing fioj_each2\n");
+  o = fiobj_ary_new2(4);
+  FIOBJ tmp = fiobj_ary_new();
+  fiobj_ary_push(o, tmp);
+  fiobj_ary_push(o, fiobj_true());
+  fiobj_ary_push(o, fiobj_null());
+  fiobj_ary_push(o, fiobj_num_new(10));
+  fiobj_ary_push(tmp, fiobj_num_new(13));
+  fiobj_ary_push(tmp, fiobj_hash_new());
+  FIOBJ key = fiobj_str_new("my key", 6);
+  fiobj_hash_set(fiobj_ary_entry(tmp, -1), key, fiobj_true());
+  fiobj_free(key);
+  /* we have root array + 4 children (w/ array) + 2 children (w/ hash) + 1 */
+  uintptr_t count = 0;
+  size_t each_ret = 0;
+  TEST_ASSERT(fiobj_each2(o, fiobject_test_task, (void *)&count) == 8,
+              "fiobj_each1 didn't count everything... (%d != %d)", (int)count,
+              (int)each_ret);
+  TEST_ASSERT(count == 8, "Something went wrong with the counter task... (%d)",
+              (int)count)
+  fprintf(stderr, "* passed.\n");
+  fprintf(stderr, "=== Testing fioj_iseq with nested items\n");
+  FIOBJ o2 = fiobj_ary_new2(4);
+  tmp = fiobj_ary_new();
+  fiobj_ary_push(o2, tmp);
+  fiobj_ary_push(o2, fiobj_true());
+  fiobj_ary_push(o2, fiobj_null());
+  fiobj_ary_push(o2, fiobj_num_new(10));
+  fiobj_ary_push(tmp, fiobj_num_new(13));
+  fiobj_ary_push(tmp, fiobj_hash_new());
+  key = fiobj_str_new("my key", 6);
+  fiobj_hash_set(fiobj_ary_entry(tmp, -1), key, fiobj_true());
+  fiobj_free(key);
+  TEST_ASSERT(!fiobj_iseq(o, FIOBJ_INVALID),
+              "Array and FIOBJ_INVALID can't be equal!");
+  TEST_ASSERT(!fiobj_iseq(o, fiobj_null()),
+              "Array and fiobj_null can't be equal!");
+  TEST_ASSERT(fiobj_iseq(o, o2), "Arrays aren't euqal!");
+  fiobj_free(o);
+  fiobj_free(o2);
+  TEST_ASSERT(fiobj_iseq(fiobj_null(), fiobj_null()),
+              "fiobj_null() not equal to self!");
+  TEST_ASSERT(fiobj_iseq(fiobj_false(), fiobj_false()),
+              "fiobj_false() not equal to self!");
+  TEST_ASSERT(fiobj_iseq(fiobj_true(), fiobj_true()),
+              "fiobj_true() not equal to self!");
+  TEST_ASSERT(!fiobj_iseq(fiobj_null(), fiobj_false()),
+              "fiobj_null eqal to fiobj_false!");
+  TEST_ASSERT(!fiobj_iseq(fiobj_null(), fiobj_true()),
+              "fiobj_null eqal to fiobj_true!");
+  fprintf(stderr, "* passed.\n");
 }
+
+#endif