iodine 0.7.3 → 0.7.4

data/ext/iodine/fiobj_hash.c

@@ -7,11 +7,13 @@ License: MIT
 
 #include <assert.h>
 #include <fiobj_hash.h>
+
 #define FIO_SET_CALLOC(size, count) fio_calloc((size), (count))
 #define FIO_SET_REALLOC(ptr, original_size, size, valid_data_length)           \
   fio_realloc2((ptr), (size), (valid_data_length))
 #define FIO_SET_FREE(ptr, size) fio_free((ptr))
-#define FIO_SET_NAME fio_hash
+
+#define FIO_SET_NAME fio_hash__
 #define FIO_SET_KEY_TYPE FIOBJ
 #define FIO_SET_KEY_COMPARE(o1, o2)                                            \
   ((o2) == ((FIOBJ)-1) || (o1) == ((FIOBJ)-1) || fiobj_iseq((o1), (o2)))
@@ -30,7 +32,6 @@ License: MIT
     (obj) = FIOBJ_INVALID;                                                     \
   } while (0)
 
-#define FIO_OVERRIDE_MALLOC 1
 #include <fio.h>
 
 #include <errno.h>
@@ -40,14 +41,14 @@ Hash types
 ***************************************************************************** */
 typedef struct {
   fiobj_object_header_s head;
-  fio_hash_s hash;
+  fio_hash___s hash;
 } fiobj_hash_s;
 
 #define obj2hash(o) ((fiobj_hash_s *)(FIOBJ2PTR(o)))
 
 void fiobj_hash_rehash(FIOBJ h) {
   assert(h && FIOBJ_TYPE_IS(h, FIOBJ_T_HASH));
-  fio_hash_rehash(&obj2hash(h)->hash);
+  fio_hash___rehash(&obj2hash(h)->hash);
 }
 
 /* *****************************************************************************
@@ -64,8 +65,8 @@ static void fiobj_hash_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
     i->obj.obj = FIOBJ_INVALID;
   }
   obj2hash(o)->hash.count = 0;
-  fio_hash_free(&obj2hash(o)->hash);
-  free(FIOBJ2PTR(o));
+  fio_hash___free(&obj2hash(o)->hash);
+  fio_free(FIOBJ2PTR(o));
 }
 
 static __thread FIOBJ each_at_key = FIOBJ_INVALID;
@@ -74,7 +75,7 @@ static size_t fiobj_hash_each1(FIOBJ o, size_t start_at,
                                int (*task)(FIOBJ obj, void *arg), void *arg) {
   assert(o && FIOBJ_TYPE_IS(o, FIOBJ_T_HASH));
   FIOBJ old_each_at_key = each_at_key;
-  fio_hash_s *hash = &obj2hash(o)->hash;
+  fio_hash___s *hash = &obj2hash(o)->hash;
   size_t count = 0;
   if (hash->count == hash->pos) {
     /* no holes in the hash, we can work as we please. */
@@ -112,8 +113,8 @@ end:
 FIOBJ fiobj_hash_key_in_loop(void) { return each_at_key; }
 
 static size_t fiobj_hash_is_eq(const FIOBJ self, const FIOBJ other) {
-  if (fio_hash_count(&obj2hash(self)->hash) !=
-      fio_hash_count(&obj2hash(other)->hash))
+  if (fio_hash___count(&obj2hash(self)->hash) !=
+      fio_hash___count(&obj2hash(other)->hash))
     return 0;
   return 1;
 }
@@ -121,7 +122,7 @@ static size_t fiobj_hash_is_eq(const FIOBJ self, const FIOBJ other) {
 /** Returns the number of elements in the Array. */
 size_t fiobj_hash_count(const FIOBJ o) {
   assert(o && FIOBJ_TYPE_IS(o, FIOBJ_T_HASH));
-  return fio_hash_count(&obj2hash(o)->hash);
+  return fio_hash___count(&obj2hash(o)->hash);
 }
 
 intptr_t fiobj_hash2num(const FIOBJ o) { return (intptr_t)fiobj_hash_count(o); }
@@ -157,7 +158,7 @@ Hash API
  * retain order of object insertion.
  */
 FIOBJ fiobj_hash_new(void) {
-  fiobj_hash_s *h = malloc(sizeof(*h));
+  fiobj_hash_s *h = fio_malloc(sizeof(*h));
   FIO_ASSERT_ALLOC(h);
   *h = (fiobj_hash_s){.head = {.ref = 1, .type = FIOBJ_T_HASH},
                       .hash = FIO_SET_INIT};
@@ -172,11 +173,11 @@ FIOBJ fiobj_hash_new(void) {
  * retain order of object insertion.
  */
 FIOBJ fiobj_hash_new2(size_t capa) {
-  fiobj_hash_s *h = malloc(sizeof(*h));
+  fiobj_hash_s *h = fio_malloc(sizeof(*h));
   FIO_ASSERT_ALLOC(h);
   *h = (fiobj_hash_s){.head = {.ref = 1, .type = FIOBJ_T_HASH},
                       .hash = FIO_SET_INIT};
-  fio_hash_capa_require(&h->hash, capa);
+  fio_hash___capa_require(&h->hash, capa);
   return (FIOBJ)h | FIOBJECT_HASH_FLAG;
 }
 
@@ -186,7 +187,7 @@ FIOBJ fiobj_hash_new2(size_t capa) {
  */
 size_t fiobj_hash_capa(const FIOBJ hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  return fio_hash_capa(&obj2hash(hash)->hash);
+  return fio_hash___capa(&obj2hash(hash)->hash);
 }
 
 /**
@@ -199,7 +200,7 @@ int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   if (FIOBJ_TYPE_IS(key, FIOBJ_T_STRING))
     fiobj_str_freeze(key);
-  fio_hash_insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, NULL);
+  fio_hash___insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, NULL);
   return 0;
 }
 
@@ -216,12 +217,12 @@ int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj) {
 FIOBJ fiobj_hash_pop(FIOBJ hash, FIOBJ *key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old;
-  if (fio_hash_count(&obj2hash(hash)->hash))
+  if (fio_hash___count(&obj2hash(hash)->hash))
     return FIOBJ_INVALID;
-  old = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash).obj);
+  old = fiobj_dup(fio_hash___last(&obj2hash(hash)->hash).obj);
   if (key)
-    *key = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash).key);
-  fio_hash_pop(&obj2hash(hash)->hash);
+    *key = fiobj_dup(fio_hash___last(&obj2hash(hash)->hash).key);
+  fio_hash___pop(&obj2hash(hash)->hash);
   return old;
 }
 
@@ -237,7 +238,7 @@ FIOBJ fiobj_hash_pop(FIOBJ hash, FIOBJ *key) {
 FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, &old);
+  fio_hash___insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, &old);
   return old;
 }
 
@@ -247,7 +248,7 @@ FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ obj) {
 FIOBJ fiobj_hash_remove(FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_remove(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, &old);
+  fio_hash___remove(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, &old);
   return old;
 }
 
@@ -258,7 +259,7 @@ FIOBJ fiobj_hash_remove(FIOBJ hash, FIOBJ key) {
 FIOBJ fiobj_hash_remove2(FIOBJ hash, uint64_t hash_value) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_remove(&obj2hash(hash)->hash, hash_value, -1, &old);
+  fio_hash___remove(&obj2hash(hash)->hash, hash_value, -1, &old);
   return old;
 }
 
@@ -283,7 +284,7 @@ int fiobj_hash_delete(FIOBJ hash, FIOBJ key) {
  * Returns -1 on type error or if the object never existed.
  */
 int fiobj_hash_delete2(FIOBJ hash, uint64_t key_hash) {
-  return fio_hash_remove(&obj2hash(hash)->hash, key_hash, -1, NULL);
+  return fio_hash___remove(&obj2hash(hash)->hash, key_hash, -1, NULL);
 }
 
 /**
@@ -292,7 +293,7 @@ int fiobj_hash_delete2(FIOBJ hash, uint64_t key_hash) {
  */
 FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  return fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key);
+  return fio_hash___find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key);
   ;
 }
 
@@ -306,7 +307,7 @@ FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key) {
  */
 FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  return fio_hash_find(&obj2hash(hash)->hash, key_hash, -1);
+  return fio_hash___find(&obj2hash(hash)->hash, key_hash, -1);
   ;
 }
 
@@ -315,7 +316,7 @@ FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash) {
  */
 int fiobj_hash_haskey(const FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  return fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key) !=
+  return fio_hash___find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key) !=
          FIOBJ_INVALID;
 }
 
@@ -324,7 +325,7 @@ int fiobj_hash_haskey(const FIOBJ hash, FIOBJ key) {
  */
 void fiobj_hash_clear(const FIOBJ hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  fio_hash_free(&obj2hash(hash)->hash);
+  fio_hash___free(&obj2hash(hash)->hash);
 }
 
 /* *****************************************************************************

data/ext/iodine/fiobj_json.c

@@ -2,10 +2,11 @@
 Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
-#include <fio.h>
 #include <fiobj_json.h>
+#define FIO_ARY_NAME fio_json_stack
+#define FIO_ARY_TYPE FIOBJ
+#include <fio.h>
 
-#include <fio_ary.h>
 #include <fio_json_parser.h>
 
 #include <assert.h>
@@ -37,7 +38,7 @@ typedef struct {
   FIOBJ key;
   FIOBJ top;
   FIOBJ target;
-  fio_ary_s stack;
+  fio_json_stack_s stack;
   uint8_t is_hash;
 } fiobj_json_parser_s;
 
@@ -95,13 +96,13 @@ 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);
+    fio_json_stack_push(&pr->stack, 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);
+    fio_json_stack_push(&pr->stack, pr->top);
     pr->top = hash;
   }
   pr->is_hash = 1;
@@ -116,7 +117,8 @@ static void fio_json_on_end_object(json_parser_s *p) {
     fiobj_free(pr->key);
     pr->key = FIOBJ_INVALID;
   }
-  pr->top = (FIOBJ)fio_ary_pop(&pr->stack);
+  pr->top = FIOBJ_INVALID;
+  fio_json_stack_pop(&pr->stack, &pr->top);
   pr->is_hash = FIOBJ_TYPE_IS(pr->top, FIOBJ_T_HASH);
 }
 /** an array object was detected */
@@ -124,9 +126,9 @@ 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 ary = fiobj_ary_new();
   fiobj_json_add2parser(pr, ary);
-  fio_ary_push(&pr->stack, (void *)pr->top);
+  fio_json_stack_push(&pr->stack, pr->top);
   pr->top = ary;
   pr->is_hash = 0;
   return 0;
@@ -134,14 +136,15 @@ static int fio_json_on_start_array(json_parser_s *p) {
 /** 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->top = FIOBJ_INVALID;
+  fio_json_stack_pop(&pr->stack, &pr->top);
   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);
+  // fio_json_stack_free(&pr->stack);
   (void)p; /* nothing special... right? */
 }
 /** the JSON parsing is complete */
@@ -150,10 +153,9 @@ static void fio_json_on_error(json_parser_s *p) {
 #if DEBUG
   FIO_LOG_DEBUG("JSON on error called.");
 #endif
-  fiobj_free((FIOBJ)fio_ary_index(&pr->stack, 0));
+  fiobj_free((FIOBJ)fio_json_stack_get(&pr->stack, 0));
   fiobj_free(pr->key);
-  fio_ary_free(&pr->stack);
-  pr->stack = FIO_ARY_INIT;
+  fio_json_stack_free(&pr->stack);
   *pr = (fiobj_json_parser_s){.top = FIOBJ_INVALID};
 }
 
@@ -260,7 +262,7 @@ static void write_safe_str(FIOBJ dest, const FIOBJ str) {
 typedef struct {
   FIOBJ dest;
   FIOBJ parent;
-  fio_ary_s *stack;
+  fio_json_stack_s *stack;
   uintptr_t count;
   uint8_t pretty;
 } obj2json_data_s;
@@ -291,8 +293,8 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
 
   case FIOBJ_T_ARRAY:
     --data->count;
-    fio_ary_push(data->stack, (void *)data->parent);
-    fio_ary_push(data->stack, (void *)data->count);
+    fio_json_stack_push(data->stack, data->parent);
+    fio_json_stack_push(data->stack, (FIOBJ)data->count);
     data->parent = o;
     data->count = fiobj_ary_count(o);
     fiobj_str_write(data->dest, "[", 1);
@@ -301,8 +303,8 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
 
   case FIOBJ_T_HASH:
     --data->count;
-    fio_ary_push(data->stack, (void *)data->parent);
-    fio_ary_push(data->stack, (void *)data->count);
+    fio_json_stack_push(data->stack, data->parent);
+    fio_json_stack_push(data->stack, (FIOBJ)data->count);
     data->parent = o;
     data->count = fiobj_hash_count(o);
     fiobj_str_write(data->dest, "{", 1);
@@ -310,8 +312,9 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
     break;
   }
   if (data->pretty) {
-    fiobj_str_capa_assert(data->dest, fiobj_obj2cstr(data->dest).len +
-                                          (fio_ary_count(data->stack) * 5));
+    fiobj_str_capa_assert(data->dest,
+                          fiobj_obj2cstr(data->dest).len +
+                              (fio_json_stack_count(data->stack) * 5));
     while (!data->count && data->parent) {
       if (FIOBJ_TYPE_IS(data->parent, FIOBJ_T_HASH)) {
         fiobj_str_write(data->dest, "}", 1);
@@ -319,13 +322,15 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
         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);
+      data->count = 0;
+      fio_json_stack_pop(data->stack, &data->count);
+      data->parent = FIOBJ_INVALID;
+      fio_json_stack_pop(data->stack, &data->parent);
     }
 
     if (add_seperator && data->parent) {
       fiobj_str_write(data->dest, ",\n", 2);
-      uintptr_t indent = fio_ary_count(data->stack) - 1;
+      uintptr_t indent = fio_json_stack_count(data->stack) - 1;
       fiobj_str_capa_assert(data->dest,
                             fiobj_obj2cstr(data->dest).len + (indent * 2));
       fio_str_info_s buf = fiobj_obj2cstr(data->dest);
@@ -336,8 +341,9 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
       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));
+    fiobj_str_capa_assert(data->dest,
+                          fiobj_obj2cstr(data->dest).len +
+                              (fio_json_stack_count(data->stack) << 1));
     while (!data->count && data->parent) {
       if (FIOBJ_TYPE_IS(data->parent, FIOBJ_T_HASH)) {
         fiobj_str_write(data->dest, "}", 1);
@@ -345,8 +351,10 @@ static int fiobj_obj2json_task(FIOBJ o, void *data_) {
         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);
+      data->count = 0;
+      data->parent = FIOBJ_INVALID;
+      fio_json_stack_pop(data->stack, &data->count);
+      fio_json_stack_pop(data->stack, &data->parent);
     }
 
     if (add_seperator && data->parent) {
@@ -371,10 +379,10 @@ 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));
+    fiobj_free(fio_json_stack_get(&p.stack, 0));
     p.top = FIOBJ_INVALID;
   }
-  fio_ary_free(&p.stack);
+  fio_json_stack_free(&p.stack);
   fiobj_free(p.key);
   *pobj = p.top;
   return consumed;
@@ -397,7 +405,7 @@ size_t fiobj_hash_update_json(FIOBJ hash, const void *data, size_t len) {
     return 0;
   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);
+  fio_json_stack_free(&p.stack);
   fiobj_free(p.key);
   if (p.top != hash)
     fiobj_free(p.top);
@@ -414,7 +422,7 @@ FIOBJ fiobj_obj2json2(FIOBJ dest, FIOBJ o, uint8_t pretty) {
     fiobj_str_write(dest, "null", 4);
     return 0;
   }
-  fio_ary_s stack = FIO_ARY_INIT;
+  fio_json_stack_s stack = FIO_ARY_INIT;
   obj2json_data_s data = {
       .dest = dest,
       .stack = &stack,
@@ -425,9 +433,8 @@ FIOBJ fiobj_obj2json2(FIOBJ dest, FIOBJ o, uint8_t pretty) {
     fiobj_obj2json_task(o, &data);
     return dest;
   }
-  fio_ary_new(&stack, 0);
   fiobj_each2(o, fiobj_obj2json_task, &data);
-  fio_ary_free(&stack);
+  fio_json_stack_free(&stack);
   return dest;
 }
 

data/ext/iodine/fiobj_numbers.c

@@ -6,7 +6,6 @@ License: MIT
 #include <fiobj_numbers.h>
 #include <fiobject.h>
 
-#define FIO_OVERRIDE_MALLOC 1
 #include <fio.h>
 
 #include <assert.h>
@@ -105,7 +104,7 @@ Number API
 
 /** Creates a Number object. Remember to use `fiobj_free`. */
 FIOBJ fiobj_num_new_bignum(intptr_t num) {
-  fiobj_num_s *o = malloc(sizeof(*o));
+  fiobj_num_s *o = fio_malloc(sizeof(*o));
   if (!o) {
     perror("ERROR: fiobj number couldn't allocate memory");
     exit(errno);
@@ -143,7 +142,7 @@ Float API
 
 /** Creates a Float object. Remember to use `fiobj_free`.  */
 FIOBJ fiobj_float_new(double num) {
-  fiobj_float_s *o = malloc(sizeof(*o));
+  fiobj_float_s *o = fio_malloc(sizeof(*o));
   if (!o) {
     perror("ERROR: fiobj float couldn't allocate memory");
     exit(errno);
@@ -179,307 +178,6 @@ FIOBJ fiobj_float_tmp(double num) {
   return (FIOBJ)&ret;
 }
 
-/* *****************************************************************************
-Strings to Numbers
-***************************************************************************** */
-
-/**
- * A helper function that converts between String data to a signed int64_t.
- *
- * Numbers are assumed to be in base 10. Octal (`0###`), Hex (`0x##`/`x##`) and
- * binary (`0b##`/ `b##`) are recognized as well. For binary Most Significant
- * Bit must come first.
- *
- * The most significant differance between this function and `strtol` (aside of
- * API design), is the added support for binary representations.
- */
-#pragma weak fio_atol
-int64_t __attribute__((weak)) fio_atol(char **pstr) {
-  /* No binary representation in strtol */
-  char *str = *pstr;
-  uint64_t result = 0;
-  uint8_t invert = 0;
-  while (str[0] == '-') {
-    invert ^= 1;
-    ++str;
-  }
-  if (str[0] == 'B' || str[0] == 'b' ||
-      (str[0] == '0' && (str[1] == 'b' || str[1] == 'B'))) {
-    /* base 2 */
-    if (str[0] == '0')
-      str++;
-    str++;
-    while (str[0] == '0' || str[0] == '1') {
-      result = (result << 1) | (str[0] == '1');
-      str++;
-    }
-  } else if (str[0] == 'x' || str[0] == 'X' ||
-             (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))) {
-    /* base 16 */
-    uint8_t tmp;
-    if (str[0] == '0')
-      str++;
-    str++;
-    for (;;) {
-      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 if (str[0] == '0') {
-    ++str;
-    /* base 8 */
-    const char *end = str;
-    while (end[0] >= '0' && end[0] <= '7' && (uintptr_t)(end - str) < 22)
-      end++;
-    if ((uintptr_t)(end - str) > 21) /* TODO: fix too large for a number */
-      return 0;
-
-    while (str < end) {
-      result = (result * 8) + (str[0] - '0');
-      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;
-}
-
-/** A helper function that converts between String data to a signed double. */
-#pragma weak fio_atof
-double __attribute__((weak)) fio_atof(char **pstr) {
-  return strtold(*pstr, pstr);
-}
-
-/* *****************************************************************************
-Numbers to Strings
-***************************************************************************** */
-
-/**
- * A helper function that writes a signed int64_t to a string.
- *
- * No overflow guard is provided, make sure there's at least 68 bytes
- * available (for base 2).
- *
- * Offers special support for base 2 (binary), base 8 (octal), base 10 and base
- * 16 (hex). An unsupported base will silently default to base 10. Prefixes
- * are automatically added (i.e., "0x" for hex and "0b" for base 2).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-#pragma weak fio_ltoa
-size_t __attribute__((weak)) fio_ltoa(char *dest, int64_t num, uint8_t base) {
-  const char notation[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-  size_t len = 0;
-  char buf[48]; /* we only need up to 20 for base 10, but base 3 needs 41... */
-
-  if (!num)
-    goto zero;
-
-  switch (base) {
-  case 1:
-  case 2:
-    /* Base 2 */
-    {
-      uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-      uint8_t i = 0;    /* counting bits */
-      dest[len++] = '0';
-      dest[len++] = 'b';
-
-      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++;
-      }
-      dest[len] = 0;
-      return len;
-    }
-  case 8:
-    /* Base 8 */
-    {
-      uint64_t l = 0;
-      if (num < 0) {
-        dest[len++] = '-';
-        num = 0 - num;
-      }
-      dest[len++] = '0';
-
-      while (num) {
-        buf[l++] = '0' + (num & 7);
-        num = num >> 3;
-      }
-      while (l) {
-        --l;
-        dest[len++] = buf[l];
-      }
-      dest[len] = 0;
-      return len;
-    }
-
-  case 16:
-    /* Base 16 */
-    {
-      uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-      uint8_t i = 0;    /* counting bits */
-      dest[len++] = '0';
-      dest[len++] = 'x';
-      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) {
-        uint8_t tmp = (n & 0xF000000000000000) >> 60;
-        dest[len++] = notation[tmp];
-        tmp = (n & 0x0F00000000000000) >> 56;
-        dest[len++] = notation[tmp];
-        i++;
-        n = n << 8;
-      }
-      dest[len] = 0;
-      return len;
-    }
-  case 3:
-  case 4:
-  case 5:
-  case 6:
-  case 7:
-  case 9:
-    /* rare bases */
-    if (num < 0) {
-      dest[len++] = '-';
-      num = 0 - num;
-    }
-    uint64_t l = 0;
-    while (num) {
-      uint64_t t = num / base;
-      buf[l++] = '0' + (num - (t * base));
-      num = t;
-    }
-    while (l) {
-      --l;
-      dest[len++] = buf[l];
-    }
-    dest[len] = 0;
-    return len;
-
-  default:
-    break;
-  }
-  /* Base 10, the default base */
-
-  if (num < 0) {
-    dest[len++] = '-';
-    num = 0 - num;
-  }
-  uint64_t l = 0;
-  while (num) {
-    uint64_t t = num / 10;
-    buf[l++] = '0' + (num - (t * 10));
-    num = t;
-  }
-  while (l) {
-    --l;
-    dest[len++] = buf[l];
-  }
-  dest[len] = 0;
-  return len;
-
-zero:
-  switch (base) {
-  case 1:
-  case 2:
-    dest[len++] = '0';
-    dest[len++] = 'b';
-  case 16:
-    dest[len++] = '0';
-    dest[len++] = 'x';
-    dest[len++] = '0';
-  }
-  dest[len++] = '0';
-  dest[len] = 0;
-  return len;
-}
-
-/**
- * A helper function that converts 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).
- */
-#pragma weak fio_ftoa
-size_t __attribute__((weak)) 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);
-  }
-
-  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';
-  }
-  return written;
-}
-
 /* *****************************************************************************
 Numbers to Strings - Buffered
 ***************************************************************************** */