iodine 0.4.19 → 0.5.0

data/ext/iodine/fiobj_hash.h

@@ -1,12 +1,26 @@
-#ifndef H_FIOBJ_HASH_H
-#define H_FIOBJ_HASH_H
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
+#ifndef H_FIOBJ_HASH_H
+/**
+ * The facil.io Hash object is an ordered Hash Table implementation.
+ *
+ * By compromising some of the HashMap's collision resistance (comparing only
+ * the Hash values rather than comparing key 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.
+ */
+#define H_FIOBJ_HASH_H
 
+#include "fiobject.h"
+
+#include "fio_siphash.h"
 #include "fiobj_str.h"
-#include "fiobj_sym.h"
+#include <errno.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,111 +29,144 @@ extern "C" {
 /* 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);
+void fiobj_hash_rehash(FIOBJ h);
 
 /* *****************************************************************************
-Couplets API - the Key-Value pair, created by the Hash object
+Hash Creation
 ***************************************************************************** */
 
-/** 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.
+ * Creates a mutable empty Hash object. Use `fiobj_free` when done.
  *
- * Otherwise returns NULL.
+ * Notice that these Hash objects are optimized for smaller collections and
+ * retain order of object insertion.
  */
-fiobj_s *fiobj_couplet2key(const fiobj_s *obj);
+FIOBJ fiobj_hash_new(void);
 
 /**
- * If object is a Hash couplet (occurs in `fiobj_each2`), returns the object
- * (the value) from the key-value pair.
+ * Creates a mutable empty Hash object with an initial capacity of `capa`. Use
+ * `fiobj_free` when done.
  *
- * Otherwise returns NULL.
+ * This allows optimizations for larger (or smaller) collections.
  */
-fiobj_s *fiobj_couplet2obj(const fiobj_s *obj);
+FIOBJ fiobj_hash_new2(size_t capa);
 
 /* *****************************************************************************
-Hash API
+Hash properties and state
 ***************************************************************************** */
 
-/** Hash type identifier.
+/**
+ * Returns a temporary theoretical Hash map capacity.
+ * This could be used for testig performance and memory consumption.
+ */
+size_t fiobj_hash_capa(const FIOBJ hash);
 
-The facil.io Hash object is, by default, an insecure (non-collision resistant)
-ordered Hash Table implementation.
+/** Returns the number of elements in the Hash. */
+size_t fiobj_hash_count(const FIOBJ hash);
 
-By being non-collision resistant (comparing only the Hash data), memory
-comparison can be avoided and performance increased.
+/** Returns the key for the object in the current `fiobj_each` loop (if any). */
+FIOBJ fiobj_hash_key_in_loop(void);
 
-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;
+/* *****************************************************************************
+Populating the Hash
+***************************************************************************** */
 
 /**
- * Creates a mutable empty Hash object. Use `fiobj_free` when done.
+ * Sets a key-value pair in the Hash, duplicating the Symbol and **moving**
+ * the ownership of the object to the Hash.
  *
- * Notice that these Hash objects are optimized for smaller collections and
- * retain order of object insertion.
+ * Returns -1 on error.
  */
-fiobj_s *fiobj_hash_new(void);
+int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj);
 
-/** Returns the number of elements in the Hash. */
-size_t fiobj_hash_count(const fiobj_s *hash);
+/**
+ * Allows the Hash to be used as a stack.
+ *
+ * If a pointer `key` is provided, it will receive ownership of the key
+ * (remember to free).
+ *
+ * Returns FIOBJ_INVALID on error.
+ *
+ * Returns and object if successful (remember to free).
+ */
+FIOBJ fiobj_hash_pop(FIOBJ hash, FIOBJ *key);
 
 /**
- * Sets a key-value pair in the Hash, duplicating the Symbol and **moving**
- * the ownership of the object to the Hash.
+ * Replaces the value in a key-value pair, returning the old value (and it's
+ * ownership) to the caller.
  *
- * Returns -1 on error.
+ * A return value of FIOBJ_INVALID indicates that no previous object existed
+ * (but a new key-value pair was created.
+ *
+ * Errors are silently ignored.
+ *
+ * Remember to free the returned object.
  */
-int fiobj_hash_set(fiobj_s *hash, fiobj_s *sym, fiobj_s *obj);
+FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ 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);
+FIOBJ fiobj_hash_remove(FIOBJ hash, FIOBJ key);
+
+/**
+ * Removes a key-value pair from the Hash, if it exists, returning the old
+ * object (instead of freeing it).
+ */
+FIOBJ fiobj_hash_remove2(FIOBJ hash, uint64_t key_hash);
+
+/**
+ * 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 hash, FIOBJ key);
 
 /**
  * Deletes a key-value pair from the Hash, if it exists, freeing the
  * associated object.
  *
+ * This function takes a `uint64_t` Hash value (see `fio_siphash`) to
+ * perform a lookup in the HashMap, which is slightly faster than the other
+ * variations.
+ *
  * Returns -1 on type error or if the object never existed.
  */
-int fiobj_hash_delete(fiobj_s *hash, fiobj_s *sym);
+int fiobj_hash_delete2(FIOBJ hash, uint64_t key_hash);
 
 /**
- * Returns a temporary handle to the object associated with the Symbol, NULL
- * if none.
+ * Returns a temporary handle to the object associated with the Symbol,
+ * FIOBJ_INVALID if none.
  */
-fiobj_s *fiobj_hash_get(const fiobj_s *hash, fiobj_s *sym);
+FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key);
 
 /**
- * Returns a temporary handle to the object associated with the Symbol C string.
+ * Returns a temporary handle to the object associated hashed key value.
  *
- * 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.
+ * This function takes a `uint64_t` Hash value (see `fio_siphash`) to
+ * perform a lookup in the HashMap, which is slightly faster than the other
+ * variations.
  *
- * Returns NULL if no object is asociated with this String data.
+ * Returns FIOBJ_INVALID if no object is asociated with this hashed key value.
  */
-fiobj_s *fiobj_hash_get2(const fiobj_s *hash, const char *str, size_t len);
+FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash);
 
 /**
  * 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);
+int fiobj_hash_haskey(const FIOBJ hash, FIOBJ key);
 
 /**
- * Returns a temporary theoretical Hash map capacity.
- * This could be used for testig performance and memory consumption.
+ * Empties the Hash.
  */
-size_t fiobj_hash_capa(const fiobj_s *hash);
+void fiobj_hash_clear(const FIOBJ hash);
+
+#if DEBUG
+void fiobj_test_hash(void);
+#endif
 
 #ifdef __cplusplus
 } /* extern "C" */

data/ext/iodine/fiobj_json.c

@@ -1,10 +1,13 @@
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 #include "fiobj_json.h"
+#include "fio_json_parser.h"
 
-// #include "fio2resp.h"
+#include "fio_ary.h"
+
+#include <assert.h>
 #include <ctype.h>
 #include <math.h>
 #include <stdlib.h>
@@ -13,81 +16,158 @@ License: MIT
 /* *****************************************************************************
 JSON API
 ***************************************************************************** */
-#define JSON_MAX_DEPTH 24
+
 /**
  * Parses JSON, setting `pobj` to point to the new Object.
  *
  * Returns the number of bytes consumed. On Error, 0 is returned and no data is
  * consumed.
  */
-size_t fiobj_json2obj(fiobj_s **pobj, const void *data, size_t len);
+size_t fiobj_json2obj(FIOBJ *pobj, const void *data, size_t len);
 /* Formats an object into a JSON string. Remember to `fiobj_free`. */
-fiobj_s *fiobj_obj2json(fiobj_s *, uint8_t);
+FIOBJ fiobj_obj2json(FIOBJ, uint8_t);
+
+/* *****************************************************************************
+FIOBJ Parser
+***************************************************************************** */
+
+typedef struct {
+  json_parser_s p;
+  FIOBJ key;
+  FIOBJ top;
+  FIOBJ target;
+  fio_ary_s stack;
+  uint8_t is_hash;
+} fiobj_json_parser_s;
 
 /* *****************************************************************************
-JSON UTF-8 safe string formatting
+FIOBJ Callacks
 ***************************************************************************** */
 
-static const char hex_chars[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-static const uint8_t is_hex[] = {
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  1,  2,  3,  4, 5, 6, 7, 8, 9, 10, 0,  0,
-    0,  0,  0,  0, 0, 11, 12, 13, 14, 15, 16, 0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 11, 12, 13,
-    14, 15, 16, 0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
-    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0};
-
-// /* invalid byte length is ignored */
-// static inline int utf8_clen(const uint8_t *str) {
-//   if (str[0] <= 127)
-//     return 1;
-//   if ((str[0] & 224) == 192 && (str[1] & 192) == 128)
-//     return 2;
-//   if ((str[0] & 240) == 224 && (str[1] & 192) == 128 && (str[2] & 192) ==
-//   128)
-//     return 3;
-//   if ((str[0] & 248) == 240 && (str[1] & 192) == 128 && (str[2] & 192) == 128
-//   &&
-//       (str[3] & 192) == 128)
-//     return 4;
-//   return 0; /* invalid UTF-8 */
-// }
-
-/* converts a uint16_t to UTF-8 and returns the number of bytes written */
-static inline int utf8_from_u32(uint8_t *dest, uint32_t u) {
-  if (u <= 127) {
-    *dest = u;
-    return 1;
-  } else if (u <= 2047) {
-    *(dest++) = 192 | (u >> 6);
-    *(dest++) = 128 | (u & 63);
-    return 2;
-  } else if (u <= 65535) {
-    *(dest++) = 224 | (u >> 12);
-    *(dest++) = 128 | ((u >> 6) & 63);
-    *(dest++) = 128 | (u & 63);
-    return 3;
+static inline void fiobj_json_add2parser(fiobj_json_parser_s *p, FIOBJ o) {
+  if (p->top) {
+    if (p->is_hash) {
+      if (p->key) {
+        fiobj_hash_set(p->top, p->key, o);
+        fiobj_free(p->key);
+        p->key = FIOBJ_INVALID;
+      } else {
+        p->key = o;
+      }
+    } else {
+      fiobj_ary_push(p->top, o);
+    }
+  } else {
+    p->top = o;
+  }
+}
+
+/** a NULL object was detected */
+static void fio_json_on_null(json_parser_s *p) {
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, fiobj_null());
+}
+/** a TRUE object was detected */
+static void fio_json_on_true(json_parser_s *p) {
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, fiobj_true());
+}
+/** a FALSE object was detected */
+static void fio_json_on_false(json_parser_s *p) {
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, fiobj_false());
+}
+/** a Numberl was detected (long long). */
+static void fio_json_on_number(json_parser_s *p, long long i) {
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, fiobj_num_new(i));
+}
+/** a Float was detected (double). */
+static void fio_json_on_float(json_parser_s *p, double f) {
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, fiobj_float_new(f));
+}
+/** a String was detected (int / float). update `pos` to point at ending */
+static void fio_json_on_string(json_parser_s *p, void *start, size_t length) {
+  FIOBJ str = fiobj_str_buf(length);
+  fiobj_str_resize(
+      str, fio_json_unescape_str(fiobj_obj2cstr(str).data, start, length));
+  fiobj_json_add2parser((fiobj_json_parser_s *)p, str);
+}
+/** a dictionary object was detected */
+static int fio_json_on_start_object(json_parser_s *p) {
+  fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+  if (pr->target) {
+    /* push NULL, don't free the objects */
+    fio_ary_push(&pr->stack, (void *)pr->top);
+    pr->top = pr->target;
+    pr->target = FIOBJ_INVALID;
+  } else {
+    FIOBJ hash = fiobj_hash_new();
+    fiobj_json_add2parser(pr, hash);
+    fio_ary_push(&pr->stack, (void *)pr->top);
+    pr->top = hash;
+  }
+  pr->is_hash = 1;
+  return 0;
+}
+/** a dictionary object closure detected */
+static void fio_json_on_end_object(json_parser_s *p) {
+  fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+  if (pr->key) {
+    fprintf(stderr, "WARNING: (JSON parsing) malformed JSON, "
+                    "ignoring dangling Hash key.\n");
+    fiobj_free(pr->key);
+    pr->key = FIOBJ_INVALID;
   }
-  *(dest++) = 240 | ((u >> 18) & 7);
-  *(dest++) = 128 | ((u >> 12) & 63);
-  *(dest++) = 128 | ((u >> 6) & 63);
-  *(dest++) = 128 | (u & 63);
-  return 4;
+  pr->top = (FIOBJ)fio_ary_pop(&pr->stack);
+  pr->is_hash = FIOBJ_TYPE_IS(pr->top, FIOBJ_T_HASH);
+}
+/** an array object was detected */
+static int fio_json_on_start_array(json_parser_s *p) {
+  fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+  if (pr->target)
+    return -1;
+  FIOBJ ary = fiobj_ary_new2(4);
+  fiobj_json_add2parser(pr, ary);
+  fio_ary_push(&pr->stack, (void *)pr->top);
+  pr->top = ary;
+  pr->is_hash = 0;
+  return 0;
+}
+/** an array closure was detected */
+static void fio_json_on_end_array(json_parser_s *p) {
+  fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+  pr->top = (FIOBJ)fio_ary_pop(&pr->stack);
+  pr->is_hash = FIOBJ_TYPE_IS(pr->top, FIOBJ_T_HASH);
+}
+/** the JSON parsing is complete */
+static void fio_json_on_json(json_parser_s *p) {
+  // fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+  // FIO_ARY_FOR(&pr->stack, pos) { fiobj_free((FIOBJ)pos.obj); }
+  // fio_ary_free(&pr->stack);
+  (void)p; /* nothing special... right? */
 }
+/** the JSON parsing is complete */
+static void fio_json_on_error(json_parser_s *p) {
+  fiobj_json_parser_s *pr = (fiobj_json_parser_s *)p;
+#if DEBUG
+  fprintf(stderr, "ERROR: JSON on error called.\n");
+#endif
+  fiobj_free((FIOBJ)fio_ary_index(&pr->stack, 0));
+  fiobj_free(pr->key);
+  fio_ary_free(&pr->stack);
+  pr->stack = FIO_ARY_INIT;
+  *pr = (fiobj_json_parser_s){.top = FIOBJ_INVALID};
+}
+
+/* *****************************************************************************
+JSON formatting
+***************************************************************************** */
 
 /** Writes a JSON friendly version of the src String */
-static void write_safe_str(fiobj_s *dest, const fiobj_s *str) {
+static void write_safe_str(FIOBJ dest, const FIOBJ str) {
   fio_cstr_s s = fiobj_obj2cstr(str);
   fio_cstr_s t = fiobj_obj2cstr(dest);
+  t.data[t.len] = '"';
+  t.len++;
+  fiobj_str_resize(dest, t.len);
+  t = fiobj_obj2cstr(dest);
   const uint8_t *restrict src = (const uint8_t *)s.data;
   size_t len = s.len;
   uint64_t end = t.len;
@@ -95,15 +175,18 @@ static void write_safe_str(fiobj_s *dest, const fiobj_s *str) {
   size_t added = 0;
   size_t capa = fiobj_str_capa(dest);
   if (capa <= end + s.len + 64) {
-    capa = (((capa >> 12) + 1) << 12) - 1;
-    fiobj_str_capa_assert(dest, capa);
+    if (0) {
+      capa = (((capa >> 12) + 1) << 12) - 1;
+      capa = fiobj_str_capa_assert(dest, capa);
+    } else {
+      capa = fiobj_str_capa_assert(dest, (end + s.len + 64));
+    }
     fio_cstr_s tmp = fiobj_obj2cstr(dest);
     t = tmp;
   }
   while (len) {
     char *restrict writer = (char *)t.data;
-    while (len &&
-           (src[0] > 32 && src[0] != '"' && src[0] != '\\' && src[0] != '/')) {
+    while (len && (src[0] > 32 && src[0] != '"' && src[0] != '\\')) {
       len--;
       writer[end++] = *(src++);
     }
@@ -159,575 +242,369 @@ static void write_safe_str(fiobj_s *dest, const fiobj_s *str) {
     src++;
     len--;
     if (added >= 48 && capa <= end + len + 64) {
-      capa = (((capa >> 12) + 1) << 12) - 1;
-      fiobj_str_capa_assert(dest, capa);
+      if (0) {
+        capa = (((capa >> 12) + 1) << 12) - 1;
+        capa = fiobj_str_capa_assert(dest, capa);
+      } else {
+        capa = fiobj_str_capa_assert(dest, (end + len + 64));
+      }
       t = fiobj_obj2cstr(dest);
       added = 0;
     }
   }
+  t.data[end++] = '"';
   fiobj_str_resize(dest, end);
 }
 
-/* *****************************************************************************
-JSON formatting
-***************************************************************************** */
-
-/* this is used to persist data in `fiobj_each2` */
-struct fiobj_str_new_json_data_s {
-  fiobj_s *parent;  /* stores item types */
-  fiobj_s *waiting; /* stores item counts and types */
-  fiobj_s *buffer;  /* we'll write the JSON here */
-  fiobj_s *count;   /* used to persist item counts for arrays / hashes */
-  uint8_t pretty;   /* make it beautiful */
-};
-
-static int fiobj_str_new_json_task(fiobj_s *obj, void *d_) {
-  struct fiobj_str_new_json_data_s *data = d_;
-  if (data->count && fiobj_obj2num(data->count))
-    fiobj_num_set(data->count, fiobj_obj2num(data->count) - 1);
-  /* headroom */
-  fiobj_str_capa_assert(
-      data->buffer,
-      ((((fiobj_obj2cstr(data->buffer).len + 63) >> 12) + 1) << 12) - 1);
-pretty_re_rooted:
-  /* pretty? */
-  if (data->pretty) {
-    fiobj_str_write(data->buffer, "\n", 1);
-    for (size_t i = 0; i < fiobj_ary_count(data->parent); i++) {
-      fiobj_str_write(data->buffer, "  ", 2);
-    }
+typedef struct {
+  FIOBJ dest;
+  FIOBJ parent;
+  fio_ary_s *stack;
+  uintptr_t count;
+  uint8_t pretty;
+} obj2json_data_s;
+
+static int fiobj_fiobj_obj2json_task(FIOBJ o, void *data_) {
+  obj2json_data_s *data = data_;
+  uint8_t add_seperator = 1;
+  if (fiobj_hash_key_in_loop()) {
+    write_safe_str(data->dest, fiobj_hash_key_in_loop());
+    fiobj_str_write(data->dest, ":", 1);
   }
-re_rooted:
-  if (!obj) {
-    fiobj_str_write(data->buffer, "null", 4);
-    goto review_nesting;
+  switch (FIOBJ_TYPE(o)) {
+  case FIOBJ_T_NUMBER:
+  case FIOBJ_T_NULL:
+  case FIOBJ_T_TRUE:
+  case FIOBJ_T_FALSE:
+  case FIOBJ_T_FLOAT:
+    fiobj_str_join(data->dest, o);
+    --data->count;
+    break;
+
+  case FIOBJ_T_DATA:
+  case FIOBJ_T_UNKNOWN:
+  case FIOBJ_T_STRING:
+    write_safe_str(data->dest, o);
+    --data->count;
+    break;
+
+  case FIOBJ_T_ARRAY:
+    --data->count;
+    fio_ary_push(data->stack, (void *)data->parent);
+    fio_ary_push(data->stack, (void *)data->count);
+    data->parent = o;
+    data->count = fiobj_ary_count(o);
+    fiobj_str_write(data->dest, "[", 1);
+    add_seperator = 0;
+    break;
+
+  case FIOBJ_T_HASH:
+    --data->count;
+    fio_ary_push(data->stack, (void *)data->parent);
+    fio_ary_push(data->stack, (void *)data->count);
+    data->parent = o;
+    data->count = fiobj_hash_count(o);
+    fiobj_str_write(data->dest, "{", 1);
+    add_seperator = 0;
+    break;
   }
-  if (obj->type == FIOBJ_T_HASH) {
-    fiobj_str_write(data->buffer, "{", 1);
-    fiobj_ary_push(data->parent, obj);
-    fiobj_ary_push(data->waiting, data->count);
-    data->count = fiobj_num_new(fiobj_hash_count(obj));
-  } else if (obj->type == FIOBJ_T_ARRAY) {
-    fiobj_str_write(data->buffer, "[", 1);
-    /* push current state to stacks and update state */
-    fiobj_ary_push(data->parent, obj);
-    fiobj_ary_push(data->waiting, data->count);
-    data->count = fiobj_num_new(fiobj_ary_count(obj));
-  } else if (obj->type == FIOBJ_T_SYMBOL || FIOBJ_IS_STRING(obj)) {
-    fiobj_str_capa_assert(
-        data->buffer,
-        ((((fiobj_obj2cstr(data->buffer).len + 63 + fiobj_obj2cstr(obj).len) >>
-           12) +
-          1)
-         << 12) -
-            1);
-    fiobj_str_write(data->buffer, "\"", 1);
-    write_safe_str(data->buffer, obj);
-    fiobj_str_write(data->buffer, "\"", 1);
-  } else if (obj->type == FIOBJ_T_COUPLET) {
-    fiobj_str_capa_assert(data->buffer,
-                          ((((fiobj_obj2cstr(data->buffer).len + 31 +
-                              fiobj_obj2cstr(fiobj_couplet2key(obj)).len) >>
-                             12) +
-                            1)
-                           << 12) -
-                              1);
-    fiobj_str_write(data->buffer, "\"", 1);
-    write_safe_str(data->buffer, fiobj_couplet2key(obj));
-    fiobj_str_write(data->buffer, "\":", 2);
-    obj = fiobj_couplet2obj(obj);
-    if (data->pretty &&
-        (obj->type == FIOBJ_T_ARRAY || obj->type == FIOBJ_T_HASH))
-      goto pretty_re_rooted;
-    goto re_rooted;
-  } else if (obj->type == FIOBJ_T_NUMBER || obj->type == FIOBJ_T_FLOAT) {
-    fio_cstr_s i2s = fiobj_obj2cstr(obj);
-    fiobj_str_write(data->buffer, i2s.data, i2s.len);
-  } else if (obj->type == FIOBJ_T_NULL) {
-    fiobj_str_write(data->buffer, "null", 4);
-  } else if (fiobj_is_true(obj)) {
-    fiobj_str_write(data->buffer, "true", 4);
-  } else
-    fiobj_str_write(data->buffer, "false", 5);
-
-review_nesting:
-  /* print clousure to String */
-  while (!fiobj_obj2num(data->count)) {
-    fiobj_s *tmp = fiobj_ary_pop(data->parent);
-    if (!tmp)
-      break;
-    fiobj_free(data->count);
-    data->count = fiobj_ary_pop(data->waiting);
-    if (data->pretty) {
-      fiobj_str_write(data->buffer, "\n", 1);
-      for (size_t i = 0; i < fiobj_ary_count(data->parent); i++) {
-        fiobj_str_write(data->buffer, "  ", 2);
+  if (data->pretty) {
+    fiobj_str_capa_assert(data->dest, fiobj_obj2cstr(data->dest).len +
+                                          (fio_ary_count(data->stack) * 5));
+    while (!data->count && data->parent) {
+      if (FIOBJ_TYPE_IS(data->parent, FIOBJ_T_HASH)) {
+        fiobj_str_write(data->dest, "}", 1);
+      } else {
+        fiobj_str_write(data->dest, "]", 1);
       }
+      add_seperator = 1;
+      data->count = (uintptr_t)fio_ary_pop(data->stack);
+      data->parent = (FIOBJ)fio_ary_pop(data->stack);
     }
-    if (tmp->type == FIOBJ_T_ARRAY)
-      fiobj_str_write(data->buffer, "]", 1);
-    else
-      fiobj_str_write(data->buffer, "}", 1);
-  }
-  /* print object divisions to String */
-  if (data->count && fiobj_obj2num(data->count) &&
-      (!obj || (obj->type != FIOBJ_T_ARRAY && obj->type != FIOBJ_T_HASH)))
-    fiobj_str_write(data->buffer, ",", 1);
-  return 0;
-}
-
-/* Formats an object into a JSON string. Remember to `fiobj_free`. */
-fiobj_s *fiobj_obj2json(fiobj_s *obj, uint8_t pretty) {
-  /* Using a whole page size could optimize future allocations (no copy) */
-  struct fiobj_str_new_json_data_s data = {
-      .parent = fiobj_ary_new(),
-      .waiting = fiobj_ary_new(),
-      .buffer = fiobj_str_buf(0),
-      .count = NULL,
-      .pretty = pretty,
-  };
-  fiobj_each2(obj, fiobj_str_new_json_task, &data);
-
-  while (fiobj_ary_pop(data.parent))
-    ; /* we didn't duplicate the objects, so we must remove them from array */
-  fiobj_free(data.parent);
-  fiobj_free(data.waiting);
-  fiobj_str_minimize(data.buffer);
-  return data.buffer;
-}
-
-/* *****************************************************************************
-JSON parsing
-*****************************************************************************
-*/
-
-/*
-Marks as object seperators any of the following:
-
-* White Space: [0x09, 0x0A, 0x0D, 0x20]
-* Comma ("," / 0x2C)
-* Colon (":" / 0x3A)
-The rest belong to objects,
-*/
-static const uint8_t JSON_SEPERATOR[] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-};
-
-inline static void move_to_end(const uint8_t **pos, const uint8_t *limit) {
-  while (*pos < limit && JSON_SEPERATOR[**pos] == 0)
-    (*pos)++;
-}
-inline static void move_to_start(const uint8_t **pos, const uint8_t *limit) {
-  while (*pos < limit && JSON_SEPERATOR[**pos])
-    (*pos)++;
-}
-inline static uint8_t move_to_eol(const uint8_t **pos, const uint8_t *limit) {
-  /* single char lookup using library is best when target is far... */
-  if (*pos >= limit)
-    return 0;
-  if (**pos == '\n')
-    return 1;
-  void *tmp = memchr(*pos, '\n', limit - (*pos));
-  if (tmp) {
-    *pos = tmp;
-    return 1;
-  }
-  *pos = limit;
-  return 0;
-}
-
-inline static int move_to_quote(const uint8_t **pos, const uint8_t *limit) {
-  if (**pos == '\\')
-    return 1;
-  if (**pos == '\"')
-    return 0;
-  uint64_t wanted1 = 0x0101010101010101ULL * '"';
-  uint64_t wanted2 = 0x0101010101010101ULL * '\\';
-  uint64_t *lpos = (uint64_t *)*pos;
-  uint64_t *llimit = ((uint64_t *)limit) - 1;
-
-  for (; lpos < llimit; ++lpos) {
-    const uint64_t eq1 = ~((*lpos) ^ wanted1);
-    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
-    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
-    const uint64_t eq2 = ~((*lpos) ^ wanted2);
-    const uint64_t t2 = (eq2 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
-    const uint64_t t3 = (eq2 & 0x8080808080808080llu);
-    if ((t0 & t1) || (t2 & t3))
-      break;
-  }
-  *pos = (uint8_t *)lpos;
 
-  while (*pos < limit) {
-    if (**pos == '\"') {
-      return 0;
+    if (add_seperator && data->parent) {
+      fiobj_str_write(data->dest, ",\n", 2);
+      uintptr_t indent = fio_ary_count(data->stack) - 1;
+      fiobj_str_capa_assert(data->dest,
+                            fiobj_obj2cstr(data->dest).len + (indent * 2));
+      fio_cstr_s buf = fiobj_obj2cstr(data->dest);
+      while (indent--) {
+        buf.bytes[buf.len++] = ' ';
+        buf.bytes[buf.len++] = ' ';
+      }
+      fiobj_str_resize(data->dest, buf.len);
+    }
+  } else {
+    fiobj_str_capa_assert(data->dest, fiobj_obj2cstr(data->dest).len +
+                                          (fio_ary_count(data->stack) << 1));
+    while (!data->count && data->parent) {
+      if (FIOBJ_TYPE_IS(data->parent, FIOBJ_T_HASH)) {
+        fiobj_str_write(data->dest, "}", 1);
+      } else {
+        fiobj_str_write(data->dest, "]", 1);
+      }
+      add_seperator = 1;
+      data->count = (uintptr_t)fio_ary_pop(data->stack);
+      data->parent = (FIOBJ)fio_ary_pop(data->stack);
     }
-    if (**pos == '\\') {
-      return 1;
+
+    if (add_seperator && data->parent) {
+      fiobj_str_write(data->dest, ",", 1);
     }
-    (*pos)++;
   }
+
   return 0;
 }
 
 /* *****************************************************************************
-JSON UTF-8 safe string deconstruction
-*****************************************************************************
-*/
+FIOBJ API
+***************************************************************************** */
 
-/* Converts a JSON friendly String to a binary String.
+/**
+ * Parses JSON, setting `pobj` to point to the new Object.
  *
- * Also deals with the non-standard oct ("\77") and hex ("\xFF") notations
+ * Returns the number of bytes consumed. On Error, 0 is returned and no data is
+ * consumed.
  */
-static uintptr_t safestr2local(fiobj_s *str) {
-  if (str->type != FIOBJ_T_STRING && str->type != FIOBJ_T_SYMBOL) {
-    fprintf(stderr,
-            "CRITICAL ERROR: unexpected function call `safestr2local`\n");
-    exit(-1);
+size_t fiobj_json2obj(FIOBJ *pobj, const void *data, size_t len) {
+  fiobj_json_parser_s p = {.top = FIOBJ_INVALID};
+  size_t consumed = fio_json_parse(&p.p, data, len);
+  if (!consumed || p.p.depth) {
+    fiobj_free((FIOBJ)fio_ary_index(&p.stack, 0));
+    p.top = FIOBJ_INVALID;
   }
-  fio_cstr_s s = fiobj_obj2cstr(str);
-  // uint8_t had_changed = 0;
-  uint8_t *end = (uint8_t *)s.bytes + s.len;
-  uint8_t *reader = (uint8_t *)s.bytes;
-  uint8_t *writer = (uint8_t *)s.bytes;
-  while (reader < end) {
-    while (reader < end && reader[0] != '\\') {
-      *(writer++) = *(reader++);
-    }
-    if (reader[0] != '\\')
-      break;
-
-    // had_changed = 1;
-    switch (reader[1]) {
-    case 'b':
-      *(writer++) = '\b';
-      reader += 2;
-      break; /* from switch */
-    case 'f':
-      *(writer++) = '\f';
-      reader += 2;
-      break; /* from switch */
-    case 'n':
-      *(writer++) = '\n';
-      reader += 2;
-      break; /* from switch */
-    case 'r':
-      *(writer++) = '\r';
-      reader += 2;
-      break; /* from switch */
-    case 't':
-      *(writer++) = '\t';
-      reader += 2;
-      break;    /* from switch */
-    case 'u': { /* test for octal notation */
-      if (is_hex[reader[2]] && is_hex[reader[3]] && is_hex[reader[4]] &&
-          is_hex[reader[5]]) {
-        uint32_t t =
-            ((((is_hex[reader[2]] - 1) << 4) | (is_hex[reader[3]] - 1)) << 8) |
-            (((is_hex[reader[4]] - 1) << 4) | (is_hex[reader[5]] - 1));
-        if (reader[6] == '\\' && reader[7] == 'u' && is_hex[reader[8]] &&
-            is_hex[reader[9]] && is_hex[reader[10]] && is_hex[reader[11]]) {
-          /* Serrogate Pair */
-          t = (t & 0x03FF) << 10;
-          t |= ((((((is_hex[reader[8]] - 1) << 4) | (is_hex[reader[9]] - 1))
-                  << 8) |
-                 (((is_hex[reader[10]] - 1) << 4) | (is_hex[reader[11]] - 1))) &
-                0x03FF);
-          t += 0x10000;
-          /* Wikipedia way: */
-          // t = 0x10000 + ((t - 0xD800) * 0x400) +
-          //     ((((((is_hex[reader[8]] - 1) << 4) | (is_hex[reader[9]] - 1))
-          //        << 8) |
-          //       (((is_hex[reader[10]] - 1) << 4) | (is_hex[reader[11]] -
-          //       1)))
-          //       -
-          //      0xDC00);
-          reader += 6;
-        }
-        writer += utf8_from_u32(writer, t);
-        reader += 6;
-        break; /* from switch */
-      } else
-        goto invalid_escape;
-    }
-    case 'x': { /* test for hex notation */
-      if (is_hex[reader[2]] && is_hex[reader[3]]) {
-        *(writer++) = ((is_hex[reader[2]] - 1) << 4) | (is_hex[reader[3]] - 1);
-        reader += 4;
-        break; /* from switch */
-      } else
-        goto invalid_escape;
-    }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7': { /* test for octal notation */
-      if (reader[1] >= '0' && reader[1] <= '7' && reader[2] >= '0' &&
-          reader[2] <= '7') {
-        *(writer++) = ((reader[1] - '0') << 3) | (reader[2] - '0');
-        reader += 3;
-        break; /* from switch */
-      } else
-        goto invalid_escape;
-    }
-    case '"':
-    case '\\':
-    case '/':
-    /* fallthrough */
-    default:
-    invalid_escape:
-      *(writer++) = reader[1];
-      reader += 2;
-    }
-  }
-  // if(had_changed)
-  return ((uintptr_t)writer - (uintptr_t)s.bytes);
+  fio_ary_free(&p.stack);
+  fiobj_free(p.key);
+  *pobj = p.top;
+  return consumed;
 }
 
-/* *****************************************************************************
-JSON => Obj
-*****************************************************************************
-*/
-
 /**
- * Parses JSON, setting `pobj` to point to the new Object.
+ * Updates a Hash using JSON data.
+ *
+ * Parsing errors and non-dictionar object JSON data are silently ignored,
+ * attempting to update the Hash as much as possible before any errors
+ * encountered.
  *
- * Returns the number of bytes consumed. On Error, 0 is returned and no data
- * is consumed.
+ * Conflicting Hash data is overwritten (prefering the new over the old).
+ *
+ * Returns the number of bytes consumed. On Error, 0 is returned and no data is
+ * consumed.
  */
-size_t fiobj_json2obj(fiobj_s **pobj, const void *data, size_t len) {
-  if (!data) {
-    *pobj = NULL;
+size_t fiobj_hash_update_json(FIOBJ hash, const void *data, size_t len) {
+  if (!hash)
     return 0;
-  }
-  fiobj_s *nesting = fiobj_ary_new2(JSON_MAX_DEPTH + 2);
-  int64_t num;
-  const uint8_t *start;
-  fiobj_s *obj;
-  const uint8_t *end = (uint8_t *)data;
-  const uint8_t *stop = end + len;
-  uint8_t depth = 0;
-  while (1) {
-    /* skip any white space / seperators */
-    move_to_start(&end, stop);
-    /* set objcet data end point to the starting endpoint */
-    obj = NULL;
-    start = end;
-    if (end >= stop) {
-      goto finish;
-    }
-
-    /* test object type. tests are ordered by precedence, if one fails, the
-     * other is performed. */
-    if (start[0] == '"') {
-      /* object is a string (require qoutes) */
-      start++;
-      end++;
-      uint8_t dirty = 0;
-      while (move_to_quote(&end, stop)) {
-        end += 2;
-        dirty = 1;
-      }
-      if (end >= stop) {
-        goto error;
-      }
-
-      if (fiobj_ary_index(nesting, -1) &&
-          fiobj_ary_index(nesting, -1)->type == FIOBJ_T_HASH) {
-        obj = fiobj_sym_new((char *)start, end - start);
-        if (dirty)
-          fiobj_sym_reinitialize(obj, (size_t)safestr2local(obj));
-      } else {
-        obj = fiobj_str_new((char *)start, end - start);
-        if (dirty)
-          fiobj_str_resize(obj, (size_t)safestr2local(obj));
-      }
-      end++;
-
-      goto has_obj;
-    }
-    if (end[0] >= 'a' && end[0] <= 'z') {
-      if (end + 3 < stop && end[0] == 't' && end[1] == 'r' && end[2] == 'u' &&
-          end[3] == 'e') {
-        /* true */
-        end += 4;
-        obj = fiobj_true();
-        goto has_obj;
-      }
-      if (end + 4 < stop && end[0] == 'f' && end[1] == 'a' && end[2] == 'l' &&
-          end[3] == 's' && end[4] == 'e') {
-        /* false */
-        end += 5;
-        obj = fiobj_false();
-        goto has_obj;
-      }
-      if (end + 3 < stop && end[0] == 'n' && end[1] == 'u' && end[2] == 'l' &&
-          end[3] == 'l') {
-        /* null */
-        end += 4;
-        obj = fiobj_null();
-        goto has_obj;
-      }
-      goto error;
-    }
-    if (end[0] == '{') {
-      /* start an object (hash) */
-      fiobj_ary_push(nesting, fiobj_hash_new());
-      end++;
-      depth++;
-      if (depth >= JSON_MAX_DEPTH) {
-        goto error;
-      }
-      continue;
-    }
-    if (end[0] == '[') {
-      /* start an array */
-      fiobj_ary_push(nesting, fiobj_ary_new2(4));
-      end++;
-      depth++;
-      if (depth >= JSON_MAX_DEPTH) {
-        goto error;
-      }
-      continue;
-    }
-    if (end[0] == '}') {
-      /* end an object (hash) */
-      end++;
-      depth--;
-      obj = fiobj_ary_pop(nesting);
-      if (obj->type != FIOBJ_T_HASH) {
-        goto error;
-      }
-      goto has_obj;
-    }
-    if (end[0] == ']') {
-      /* end an array */
-      end++;
-      depth--;
-      obj = fiobj_ary_pop(nesting);
-      if (obj->type != FIOBJ_T_ARRAY) {
-        goto error;
-      }
-      goto has_obj;
-    }
-
-    if (end[0] == '-') {
-      if (end[0] == '-' && end[1] == 'N' && end[2] == 'a' && end[3] == 'N') {
-        move_to_end(&end, stop);
-        double fl = nan("");
-        fl = copysign(fl, (double)-1);
-        obj = fiobj_float_new(fl);
-        goto has_obj;
-      }
-      if (end[0] == '-' && end[1] == 'I' && end[2] == 'n' && end[3] == 'f') {
-        move_to_end(&end, stop);
-        double fl = INFINITY;
-        fl = copysign(fl, (double)-1);
-        obj = fiobj_float_new(fl);
-        goto has_obj;
-      }
-      goto test_for_number;
-    }
-    if (end[0] >= '0' && end[0] <= '9') {
-    test_for_number: /* test for a number OR float */
-      num = fio_atol((char **)&end);
-      if (end == start || *end == '.' || *end == 'e' || *end == 'E') {
-        end = start;
-        double fnum = fio_atof((char **)&end);
-        if (end == start)
-          goto error;
-        obj = fiobj_float_new(fnum);
-        goto has_obj;
-      }
-      obj = fiobj_num_new(num);
-      goto has_obj;
-    }
+  fiobj_json_parser_s p = {.top = FIOBJ_INVALID, .target = hash};
+  size_t consumed = fio_json_parse(&p.p, data, len);
+  fio_ary_free(&p.stack);
+  fiobj_free(p.key);
+  if (p.top != hash)
+    fiobj_free(p.top);
+  return consumed;
+}
 
-    if (end[0] == 'N' && end[1] == 'a' && end[2] == 'N') {
-      move_to_end(&end, stop);
-      obj = fiobj_float_new(nan(""));
-      goto has_obj;
-    }
-    if (end[0] == 'I' && end[1] == 'n' && end[2] == 'f') {
-      move_to_end(&end, stop);
-      obj = fiobj_float_new(INFINITY);
-      goto has_obj;
-    }
-    if (end[0] == '/') {
-      /* could be a Javascript comment */
-      if (end[1] == '/') {
-        end += 2;
-        move_to_eol(&end, stop);
-        continue;
-      }
-      if (end[1] == '*') {
-        end += 2;
-        while (end < stop && !(end[0] == '*' && end[1] == '/'))
-          end++;
-        if (end < stop && end[0] == '*')
-          end += 2;
-        continue;
-      }
-    }
-    if (end[0] == '#') {
-      /* could be a Ruby style comment */
-      move_to_eol(&end, stop);
-      continue;
-    }
-    goto error;
+/**
+ * Formats an object into a JSON string, appending the JSON string to an
+ * existing String. Remember to `fiobj_free`.
+ */
+FIOBJ fiobj_obj2json2(FIOBJ dest, FIOBJ o, uint8_t pretty) {
+  assert(dest && FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
+  if (!o) {
+    fiobj_str_write(dest, "null", 4);
+    return 0;
+  }
+  fio_ary_s stack;
+  obj2json_data_s data = {
+      .dest = dest, .stack = &stack, .pretty = pretty, .count = 1,
+  };
+  if (!o || !FIOBJ_IS_ALLOCATED(o) || !FIOBJECT2VTBL(o)->each) {
+    fiobj_fiobj_obj2json_task(o, &data);
+    return dest;
+  }
+  fio_ary_new(&stack, 0);
+  fiobj_each2(o, fiobj_fiobj_obj2json_task, &data);
+  fio_ary_free(&stack);
+  return dest;
+}
 
-  has_obj:
+/* Formats an object into a JSON string. Remember to `fiobj_free`. */
+FIOBJ fiobj_obj2json(FIOBJ obj, uint8_t pretty) {
+  return fiobj_obj2json2(fiobj_str_buf(0), obj, pretty);
+}
 
-    if (fiobj_ary_count(nesting) == 0)
-      goto finish_with_obj;
-    if (fiobj_ary_index(nesting, -1)->type == FIOBJ_T_ARRAY) {
-      fiobj_ary_push(fiobj_ary_index(nesting, -1), obj);
-      continue;
-    }
-    if (fiobj_ary_index(nesting, -1)->type == FIOBJ_T_HASH) {
-      fiobj_ary_push(nesting, obj);
-      continue;
-    }
-    fiobj_s *sym = fiobj_ary_pop(nesting);
-    if (fiobj_ary_index(nesting, -1)->type != FIOBJ_T_HASH)
-      goto error;
-    fiobj_hash_set(fiobj_ary_index(nesting, -1), sym, obj);
-    fiobj_free(sym);
-    continue;
-  }
+/* *****************************************************************************
+Test
+***************************************************************************** */
 
-finish:
-  if (!obj)
-    obj = fiobj_ary_pop(nesting);
-finish_with_obj:
-  if (obj && fiobj_ary_count(nesting) == 0) {
-    *pobj = obj;
-    fiobj_free(nesting);
-    return end - (uint8_t *)data;
+#if DEBUG
+void fiobj_test_json(void) {
+  fprintf(stderr, "=== Testing JSON parser (simple test)\n");
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, "* " __VA_ARGS__);                                         \
+    fprintf(stderr, "Testing failed.\n");                                      \
+    exit(-1);                                                                  \
   }
-error:
-  if (obj)
-    fiobj_free(obj);
-  while ((obj = fiobj_ary_pop(nesting)))
-    fiobj_free(obj);
-  fiobj_free(nesting);
-  *pobj = NULL;
-  // fprintf(stderr, "ERROR starting at %.*s, ending at %.*s, with %s\n", 3,
-  // start,
-  //         3, end, start);
-  return 0;
+  char json_str[] = "{\"array\":[1,2,3,\"boom\"],\"my\":{\"secret\":42},"
+                    "\"true\":true,\"false\":false,\"null\":null,\"float\":-2."
+                    "2,\"string\":\"I \\\"wrote\\\" this.\"}";
+  char json_str_update[] = "{\"array\":[1,2,3]}";
+  char json_str2[] =
+      "[\n    \"JSON Test Pattern pass1\",\n    {\"object with 1 "
+      "member\":[\"array with 1 element\"]},\n    {},\n    [],\n    -42,\n    "
+      "true,\n    false,\n    null,\n    {\n        \"integer\": 1234567890,\n "
+      "       \"real\": -9876.543210,\n        \"e\": 0.123456789e-12,\n       "
+      " \"E\": 1.234567890E+34,\n        \"\":  23456789012E66,\n        "
+      "\"zero\": 0,\n        \"one\": 1,\n        \"space\": \" \",\n        "
+      "\"quote\": \"\\\"\",\n        \"backslash\": \"\\\\\",\n        "
+      "\"controls\": \"\\b\\f\\n\\r\\t\",\n        \"slash\": \"/ & \\/\",\n   "
+      "     \"alpha\": \"abcdefghijklmnopqrstuvwyz\",\n        \"ALPHA\": "
+      "\"ABCDEFGHIJKLMNOPQRSTUVWYZ\",\n        \"digit\": \"0123456789\",\n    "
+      "    \"0123456789\": \"digit\",\n        \"special\": "
+      "\"`1~!@#$%^&*()_+-={':[,]}|;.</>?\",\n        \"hex\": "
+      "\"\\u0123\\u4567\\u89AB\\uCDEF\\uabcd\\uef4A\",\n        \"true\": "
+      "true,\n        \"false\": false,\n        \"null\": null,\n        "
+      "\"array\":[  ],\n        \"object\":{  },\n        \"address\": \"50 "
+      "St. James Street\",\n        \"url\": \"http://www.JSON.org/\",\n       "
+      " \"comment\": \"// /* <!-- --\",\n        \"# -- --> */\": \" \",\n     "
+      "   \" s p a c e d \" :[1,2 , 3\n\n,\n\n4 , 5        ,          6        "
+      "   ,7        ],\"compact\":[1,2,3,4,5,6,7],\n        \"jsontext\": "
+      "\"{\\\"object with 1 member\\\":[\\\"array with 1 element\\\"]}\",\n    "
+      "    \"quotes\": \"&#34; \\u0022 %22 0x22 034 &#x22;\",\n        "
+      "\"\\/"
+      "\\\\\\\"\\uCAFE\\uBABE\\uAB98\\uFCDE\\ubcda\\uef4A\\b\\f\\n\\r\\t`1~!@#$"
+      "%^&*()_+-=[]{}|;:',./<>?\"\n: \"A key can be any string\"\n    },\n    "
+      "0.5 "
+      ",98.6\n,\n99.44\n,\n\n1066,\n1e1,\n0.1e1,\n1e-1,\n1e00,2e+00,2e-00\n,"
+      "\"rosebud\"]";
+
+  FIOBJ o = 0;
+  TEST_ASSERT(fiobj_json2obj(&o, "1", 2) == 1,
+              "JSON number parsing failed to run!\n");
+  TEST_ASSERT(o, "JSON (single) object missing!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_NUMBER),
+              "JSON (single) not a number!\n");
+  TEST_ASSERT(fiobj_obj2num(o) == 1, "JSON (single) not == 1!\n");
+  fiobj_free(o);
+
+  TEST_ASSERT(fiobj_json2obj(&o, "2.0", 5) == 3,
+              "JSON float parsing failed to run!\n");
+  TEST_ASSERT(o, "JSON (float) object missing!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_FLOAT), "JSON (float) not a float!\n");
+  TEST_ASSERT(fiobj_obj2float(o) == 2, "JSON (float) not == 2!\n");
+  fiobj_free(o);
+
+  TEST_ASSERT(fiobj_json2obj(&o, json_str, sizeof(json_str)) ==
+                  (sizeof(json_str) - 1),
+              "JSON parsing failed to run!\n");
+  TEST_ASSERT(o, "JSON object missing!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_HASH),
+              "JSON root not a dictionary (not a hash)!\n");
+  FIOBJ tmp = fiobj_hash_get2(o, fio_siphash("array", 5));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_ARRAY),
+              "JSON 'array' not an Array!\n");
+  TEST_ASSERT(fiobj_obj2num(fiobj_ary_index(tmp, 0)) == 1,
+              "JSON 'array' index 0 error!\n");
+  TEST_ASSERT(fiobj_obj2num(fiobj_ary_index(tmp, 1)) == 2,
+              "JSON 'array' index 1 error!\n");
+  TEST_ASSERT(fiobj_obj2num(fiobj_ary_index(tmp, 2)) == 3,
+              "JSON 'array' index 2 error!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_ary_index(tmp, 3), FIOBJ_T_STRING),
+              "JSON 'array' index 3 type error!\n");
+  TEST_ASSERT(!memcmp("boom", fiobj_obj2cstr(fiobj_ary_index(tmp, 3)).data, 4),
+              "JSON 'array' index 3 error!\n");
+  tmp = fiobj_hash_get2(o, fio_siphash("my", 2));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_HASH),
+              "JSON 'my:secret' not a Hash!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_hash_get2(tmp, fio_siphash("secret", 6)),
+                            FIOBJ_T_NUMBER),
+              "JSON 'my:secret' doesn't hold a number!\n");
+  TEST_ASSERT(fiobj_obj2num(fiobj_hash_get2(tmp, fio_siphash("secret", 6))) ==
+                  42,
+              "JSON 'my:secret' not 42!\n");
+  TEST_ASSERT(fiobj_hash_get2(o, fio_siphash("true", 4)) == fiobj_true(),
+              "JSON 'true' not true!\n");
+  TEST_ASSERT(fiobj_hash_get2(o, fio_siphash("false", 5)) == fiobj_false(),
+              "JSON 'false' not false!\n");
+  TEST_ASSERT(fiobj_hash_get2(o, fio_siphash("null", 4)) == fiobj_null(),
+              "JSON 'null' not null!\n");
+  tmp = fiobj_hash_get2(o, fio_siphash("float", 5));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_FLOAT), "JSON 'float' not a float!\n");
+  tmp = fiobj_hash_get2(o, fio_siphash("string", 6));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_STRING),
+              "JSON 'string' not a string!\n");
+  TEST_ASSERT(!strcmp(fiobj_obj2cstr(tmp).data, "I \"wrote\" this."),
+              "JSON 'string' incorrect!\n");
+  fprintf(stderr, "* passed.\n");
+  fprintf(stderr, "=== Testing JSON formatting (simple test)\n");
+  tmp = fiobj_obj2json(o, 0);
+  fprintf(stderr, "* data (%p):\n%.*s\n", fiobj_obj2cstr(tmp).buffer,
+          (int)fiobj_obj2cstr(tmp).len, fiobj_obj2cstr(tmp).data);
+  if (!strcmp(fiobj_obj2cstr(tmp).data, json_str))
+    fprintf(stderr, "* Stringify == Original.\n");
+  TEST_ASSERT(
+      fiobj_hash_update_json(o, json_str_update, strlen(json_str_update)),
+      "JSON update failed to parse data.");
+  fiobj_free(tmp);
+
+  tmp = fiobj_hash_get2(o, fio_siphash("array", 5));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_ARRAY),
+              "JSON updated 'array' not an Array!\n");
+  TEST_ASSERT(fiobj_ary_count(tmp) == 3, "JSON updated 'array' not updated?");
+  tmp = fiobj_hash_get2(o, fio_siphash("float", 5));
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_FLOAT),
+              "JSON updated (old) 'float' missing!\n");
+  fiobj_free(o);
+  fprintf(stderr, "* passed.\n");
+
+  fprintf(stderr, "=== Testing JSON parsing (UTF-8 and special cases)\n");
+  fiobj_json2obj(&o, "[\"\\uD834\\uDD1E\"]", 16);
+  TEST_ASSERT(o, "JSON G clef String failed to parse!\n");
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY),
+              "JSON G clef container has an incorrect type! (%s)\n",
+              fiobj_type_name(o));
+  tmp = o;
+  o = fiobj_ary_pop(o);
+  fiobj_free(tmp);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING),
+              "JSON G clef String incorrect type! %p => %s\n", (void *)o,
+              fiobj_type_name(o));
+  TEST_ASSERT((!strcmp(fiobj_obj2cstr(o).data, "\xF0\x9D\x84\x9E")),
+              "JSON G clef String incorrect %s !\n", fiobj_obj2cstr(o).data);
+  fiobj_free(o);
+
+  fiobj_json2obj(&o, "\"\\uD834\\uDD1E\"", 14);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING),
+              "JSON direct G clef String incorrect type! %p => %s\n", (void *)o,
+              fiobj_type_name(o));
+  TEST_ASSERT((!strcmp(fiobj_obj2cstr(o).data, "\xF0\x9D\x84\x9E")),
+              "JSON direct G clef String incorrect %s !\n",
+              fiobj_obj2cstr(o).data);
+  fiobj_free(o);
+  fiobj_json2obj(&o, "\"Hello\\u0000World\"", 19);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING),
+              "JSON NUL containing String incorrect type! %p => %s\n",
+              (void *)o, fiobj_type_name(o));
+  TEST_ASSERT(
+      (!memcmp(fiobj_obj2cstr(o).data, "Hello\0World", fiobj_obj2cstr(o).len)),
+      "JSON NUL containing String incorrect! (%u): %s . %s\n",
+      (int)fiobj_obj2cstr(o).len, fiobj_obj2cstr(o).data,
+      fiobj_obj2cstr(o).data + 3);
+  fiobj_free(o);
+  size_t consumed = fiobj_json2obj(&o, json_str2, sizeof(json_str2));
+  TEST_ASSERT(
+      consumed == (sizeof(json_str2) - 1),
+      "JSON messy string failed to parse (consumed %lu instead of %lu\n",
+      (unsigned long)consumed, (unsigned long)(sizeof(json_str2) - 1));
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY),
+              "JSON messy string object error\n");
+  tmp = fiobj_obj2json(o, 1);
+  TEST_ASSERT(FIOBJ_TYPE_IS(tmp, FIOBJ_T_STRING),
+              "JSON messy string isn't a string\n");
+  fprintf(stderr, "Messy JSON:\n%s\n", fiobj_obj2cstr(tmp).data);
+  fiobj_free(o);
+  fiobj_free(tmp);
+  fprintf(stderr, "* passed.\n");
 }
+
+#endif